¿Qué rango de valores pueden almacenar los tipos enteros en C ++?

¿Puede unsigned long int contener un número de diez dígitos (1,000,000,000 – 9,999,999,999) en una computadora de 32 bits?

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

Los rangos mínimos en los que puede confiar son:

  • short int e int : -32,767 a 32,767
  • unsigned short int y unsigned int : 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 se puede confiar para almacenar cualquier número de 10 dígitos. Sin embargo, se introdujo long long int más grande en C en C99 y C ++ en C ++ 11 (este tipo también es a menudo soportado como una extensión por comstackdores creados para estándares más antiguos que no lo incluyeron). El rango mínimo para este tipo, si su comstackdor lo admite, 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

Entonces ese tipo será lo suficientemente grande (nuevamente, si lo tiene disponible).


Una nota para aquellos que creen que cometí un error con estos límites inferiores: no lo hice. Los requisitos de C para los rangos se escriben para permitir las representaciones enteras complementarias o de magnitud de signo, donde el valor representable más bajo y el valor representable más alto difieren solo en el signo. También se permite tener una representación de complemento de dos donde el valor con el bit de signo 1 y todos los bits de valor 0 es una representación de captura en lugar de un valor legal. En otras palabras, int no es necesario para poder representar el valor -32,768.

El tamaño de los tipos numéricos no está definido en el estándar C ++, aunque sí lo son los tamaños mínimos. La forma de decir 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 por:

 std::numeric_limits::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 se representan los números en la memoria. Tome por ejemplo ocho bits (1 byte)

  0100 1000 

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

Entonces el número representa 2 6 + 2 3 = 64 + 8 = 72, porque el 4º bit de la derecha y el 7mo bit a la izquierda se configuran.

Si establecemos todos los valores en 1:

 11111111 

El número es ahora (asumiendo sin firmar )
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, int y long son iguales, cada uno capaz de mantener entre -2 31 a 2 31 – 1. En mi experiencia, el tamaño más común en la moderna máquina de escritorio de 32 bits.

Otras personas aquí publicarán enlaces a data_sizes y precisiones, etc.
Te voy a decir cómo resolverlo tú mismo.
Escribe una pequeña aplicación que hará lo siguiente.

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

esto hará (dependiendo del comstackdor y archivo) imprimir 2, 4 u 8, diciendo 2 bytes de largo, 4 bytes de largo, etc.

Supongamos que es 4.

Ahora quiere 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's (un par de f para cada byte, el 0x le dice al comstackdor que la siguiente cadena es un número hexadecimal). Ahora cambie su progtwig para asignar ese valor e imprimir el resultado

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

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

Ahora hazlo por mucho tiempo, pantalones cortos y cualquier otro valor INTEGER del que sientas curiosidad.

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

Espero que esto ayude

Para conocer los límites de su sistema:

 #include  #include  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 es solo legal en C99 y en C ++ 11.

En C ++, ahora int y otros datos se almacenan utilizando el método de cumplido 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 menos que 2 ^ (31)

Para el tipo de datos sin signo no hay ningún bit de signo y todos los bits son para datos; mientras que para el tipo de datos firmado, MSB está indicado como bit de signo y los bits restantes son para datos.

Para encontrar el rango haga lo siguiente:

Paso: 1 -> Buscar no de bytes para el tipo de dato de datos.

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 ej.

Para unsigned int size = 4 bytes (32 bits) -> Rango [0, (2 ^ (32)) – 1]

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

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

Puede unsigned long int 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 ver las especializaciones de la plantilla numeric_limits <> para un tipo dado. Está en el encabezado.