Qué rango de valores de los tipos enteros tienda en C++

StackOverflow https://stackoverflow.com/questions/1819189

  •  10-07-2019
  •  | 
  •  

Pregunta

Puede unsigned long int mantenga un número de diez dígitos (1,000,000,000 - 9,999,999,999) en un equipo de 32 bits?

Además, ¿cuáles son los rangos de unsigned long int , long int, unsigned int, short int, short unsigned int, y int?

¿Fue útil?

Solución

El mínimo los alcances en los que puede confiar, son:

  • short int y int:- 32.767 a 32,767
  • unsigned short int y unsigned int:De 0 a 65.535
  • long int:-2,147,483,647 a 2.147.483.647
  • unsigned long int:0 a 4.294.967.295

Esto significa que no, long int no ser tomadas en consideración para almacenar cualquier número de 10 dígitos.Sin embargo, un tipo mayor long long int fue introducido a C en C99 y C++ en C++11 (este tipo es a menudo también se admite como una extensión por parte de los compiladores construido para los que no lo incluyen).El rango mínimo para este tipo, si el compilador soporta, es:

  • long long int:-9,223,372,036,854,775,807 a 9.223.372.036.854.775.807
  • unsigned long long int:0 a 18,446,744,073,709,551,615

A fin de que tipo será lo suficientemente grande (de nuevo, si la tiene disponible).

Una nota para aquellos que creen que he cometido un error con estos límites inferiores - no lo he hecho.El C requisitos para los rangos están escritas para permitir que los complementan o signo-magnitud entero representaciones, donde el menor valor representable y el máximo valor representable sólo se diferencian en el signo.También se permite tener un complemento a dos de la representación, donde el valor con el bit de signo 1 y todo el valor de los bits 0 es un la trampa de la representación en lugar de un valor jurídico.En otras palabras, int es no necesarios para ser capaces de representar el valor de -32,768.

Otros consejos

El tamaño de los tipos numéricos no está definido en el estándar C ++, aunque los tamaños mínimos sí lo están. La forma de saber qué tamaño tienen en su plataforma es usar límites numéricos

Por ejemplo, el valor máximo para un int se puede encontrar en: 

std::numeric_limits<int>::max();

Las computadoras no funcionan en la base 10, lo que significa que el valor máximo tendrá la forma de 2 n -1 debido a cómo representan los números de memoria. Tomemos por ejemplo ocho bits (1 byte) 

  0100 1000

El bit (número) más a la derecha cuando se establece en 1 representa 2 0 , el siguiente bit 2 1 , luego 2 2 y así hasta que lleguemos al bit más a la izquierda, que si el número no está firmado representa 2 7 .

Por lo tanto, el número representa 2 6 + 2 3 = 64 + 8 = 72, porque el cuarto bit de la derecha y el séptimo bit de la izquierda están configurados.

Si establecemos todos los valores en 1: 

11111111

El número es ahora (suponiendo que no está firmado )
128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255 = 2 8 - 1
Y como podemos ver, ese es el mayor valor posible que se puede representar con 8 bits.

En mi máquina e int y a long son iguales, cada uno puede contener entre -2 31 a 2 31 - 1. En mi experiencia, el tamaño más común en una moderna máquina de escritorio de 32 bits.

Para conocer los límites de su sistema: 

#include <iostream>
#include <limits>
int main(int, char **) {
  std::cout
    << static_cast< int >(std::numeric_limits< char >::max()) << "\n"
    << static_cast< int >(std::numeric_limits< unsigned char >::max()) << "\n"
    << std::numeric_limits< short >::max() << "\n"
    << std::numeric_limits< unsigned short >::max() << "\n"
    << std::numeric_limits< int >::max() << "\n"
    << std::numeric_limits< unsigned int >::max() << "\n"
    << std::numeric_limits< long >::max() << "\n"
    << std::numeric_limits< unsigned long >::max() << "\n"
    << std::numeric_limits< long long >::max() << "\n"
    << std::numeric_limits< unsigned long long >::max() << "\n";
}

Tenga en cuenta que long long solo es legal en C99 y en C ++ 11.

Otras personas aquí publicarán enlaces a data_sizes y precisions, etc.
Te diré cómo resolverlo tú mismo.
Escriba una pequeña aplicación que haga lo siguiente. 

unsigned int ui;
std::cout <<  sizeof(ui));

esto (según el compilador y el archivo) imprimirá 2, 4 u 8, diciendo 2 bytes de largo, 4 bytes de largo, etc.

Supongamos que es 4.

Ahora desea el valor máximo que pueden almacenar 4 bytes, el valor máximo para un byte es (en hexadecimal) 0xFF. El valor máximo de cuatro bytes es 0x seguido de 8 f (un par de f para cada byte, el 0x le dice al compilador que la siguiente cadena es un número hexadecimal). Ahora cambie su programa para asignar ese valor e imprima el resultado 

unsigned int ui = 0xFFFFFFFF;
std::cout <<  ui;

Es el valor máximo que puede contener un int sin signo, que se muestra en la representación de base 10.

Ahora hazlo por largos, cortos y cualquier otro valor INTEGER que te interese.

NB: este enfoque no funcionará para números de coma flotante (es decir, doble o flotante).

Espero que esto ayude

En C ++, ahora int y otros datos se almacenan utilizando el método complementario de 2. Eso significa que el rango es: 

-2147483648 to 2147483647

o -2 ^ 31 a 2 ^ 31-1

1 bit está reservado para 0, por lo que el valor positivo es uno menor que 2 ^ (31)

Para tipo de datos sin signo no hay bit de signo y todos los bits son para datos ; mientras que para tipo de datos con signo MSB se indica bit de signo y los bits restantes son para datos.

Para encontrar el rango, haga lo siguiente:

Paso: 1 - > Averigüe el número de bytes para el tipo de datos de donación.

Paso: 2 - > Aplicar los siguientes cálculos. 

      Let n = no of bits in data type  

      For signed data type ::
            Lower Range = -(2^(n-1)) 
            Upper Range = (2^(n-1)) - 1)  

      For unsigned data type ::
            Lower Range = 0 
            Upper Range = (2^(n)) - 1

Por ejemplo,

Para tamaño int sin signo = 4 bytes (32 bits) - > Rango [0, (2 ^ (32)) - 1]

Para tamaño int firmado = 4 bytes (32 bits) - > Rango [- (2 ^ (32-1)), (2 ^ (32-1)) - 1]

No, solo parte del número de diez dígitos se puede almacenar en un int largo sin signo cuyo rango válido es de 0 a 4,294,967,295. puedes referirte a esto: http://msdn.microsoft.com/en-us /library/s3f49ktz(VS.80).aspx

  

¿Puede un int largo sin firmar contener un número de diez dígitos (1,000,000,000 - 9,999,999,999) en una computadora de 32 bits.

No

Debería observar las especializaciones de los numeric_limits < > plantilla para un tipo dado. Está en el encabezado.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top