c++ ¿Qué indica el estándar de C ++ que indica el tamaño de int, el tipo largo?





12 Answers

Para sistemas de 32 bits, el estándar 'de facto' es ILP32, es decir, int , long y puntero son todas las cantidades de 32 bits.

Para sistemas de 64 bits, el estándar primario de facto de Unix es LP64: long y puntero de 64 bits (pero int es de 32 bits). El estándar de Windows de 64 bits es LLP64 - long long y el puntero son de 64 bit (pero long e int son ambos de 32 bits).

Al mismo tiempo, algunos sistemas Unix utilizaban una organización ILP64.

Ninguna de estas normas de facto está legislada por la norma C (ISO / IEC 9899: 1999), pero todas están permitidas por ella.

Y, por definición, sizeof(char) es 1 , a pesar de la prueba en el script de configuración de Perl.

Tenga en cuenta que había máquinas (Crays) donde CHAR_BIT era mucho más grande que 8. Eso significaba, IIRC, que sizeof(int) también era 1, porque tanto char como int eran de 32 bits.

c++ c++-faq

Estoy buscando información detallada sobre el tamaño de los tipos básicos de C ++. Sé que depende de la arquitectura (16 bits, 32 bits, 64 bits) y el compilador.

Pero, ¿hay algún estándar para C ++?

Estoy usando Visual Studio 2008 en una arquitectura de 32 bits. Esto es lo que obtengo:

char  : 1 byte
short : 2 bytes
int   : 4 bytes
long  : 4 bytes
float : 4 bytes
double: 8 bytes

Intenté encontrar, sin mucho éxito, información confiable que indicara los tamaños de char , short , int , long , double , float (y otros tipos en los que no pensé) bajo diferentes arquitecturas y compiladores.




Hay estándar.

El estándar C90 requiere que

sizeof(short) <= sizeof(int) <= sizeof(long)

El estándar C99 requiere que

sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long)

Aquí están las especificaciones C99 . Página 22 detalles de tamaños de diferentes tipos integrales.

Aquí está el tamaño de tipo int (bits) para plataformas Windows:

Type           C99 Minimum     Windows 32bit
char           8               8
short          16              16
int            16              32
long           32              32
long long      64              64

Si le preocupa la portabilidad, o si desea que el nombre del tipo refleje el tamaño, puede consultar el encabezado <inttypes.h> , donde están disponibles las siguientes macros:

int8_t
int16_t
int32_t
int64_t

Se garantiza que int8_t es de 8 bits, y que int16_t tiene una garantía de 16 bits, etc.




Actualizado: C ++ 11 trajo los tipos de TR1 oficialmente al estándar:

  • long long int
  • sin firmar largo largo int

Y los tipos de "tamaño" de <cstdint>

  • int8_t
  • int16_t
  • int32_t
  • int64_t
  • (y las contrapartes sin firmar).

Además usted obtiene:

  • int_least8_t
  • int_least16_t
  • int_least32_t
  • int_least64_t
  • Más las contrapartes sin firmar.

Estos tipos representan los tipos de enteros más pequeños con al menos el número especificado de bits. Del mismo modo, existen los tipos enteros "más rápidos" con al menos el número especificado de bits:

  • int_fast8_t
  • int_fast16_t
  • int_fast32_t
  • int_fast64_t
  • Más las versiones sin firmar.

Lo que "rápido" significa, en todo caso, depende de la implementación. Tampoco tiene que ser el más rápido para todos los propósitos.




No, no hay estándar para los tamaños de tipo. Estándar solo requiere que:

sizeof(short int) <= sizeof(int) <= sizeof(long int)

Lo mejor que puedes hacer si quieres variables de un tamaño fijo es usar macros como esta:

#ifdef SYSTEM_X
  #define WORD int
#else
  #define WORD long int
#endif

Luego puedes usar WORD para definir tus variables. No es que me guste esto pero es la forma más portátil .




Para los números de punto flotante hay un estándar (IEEE754) : los flotadores son de 32 bits y los dobles son 64. Este es un estándar de hardware, no un estándar de C ++, por lo que los compiladores teóricamente podrían definir flotante y doble a otro tamaño, pero en la práctica Nunca he visto una arquitectura que utilizara algo diferente.







Cuando se trata de tipos incorporados para diferentes arquitecturas y compiladores diferentes, simplemente ejecute el siguiente código en su arquitectura con su compilador para ver qué resultados produce. A continuación se muestra mi salida Ubuntu 13.04 (Raring Ringtail) de 64 bits g ++ 4.7.3. También tenga en cuenta lo que se respondió a continuación, por lo que la salida se ordena como tal:

"Hay cinco tipos de enteros con signo estándar: char con signo, int corto, int, int largo y int largo largo. En esta lista, cada tipo proporciona al menos tanto almacenamiento como los que lo preceden en la lista".

#include <iostream>

int main ( int argc, char * argv[] )
{
  std::cout<< "size of char: " << sizeof (char) << std::endl;
  std::cout<< "size of short: " << sizeof (short) << std::endl;
  std::cout<< "size of int: " << sizeof (int) << std::endl;
  std::cout<< "size of long: " << sizeof (long) << std::endl;
  std::cout<< "size of long long: " << sizeof (long long) << std::endl;

  std::cout<< "size of float: " << sizeof (float) << std::endl;
  std::cout<< "size of double: " << sizeof (double) << std::endl;

  std::cout<< "size of pointer: " << sizeof (int *) << std::endl;
}


size of char: 1
size of short: 2
size of int: 4
size of long: 8
size of long long: 8
size of float: 4
size of double: 8
size of pointer: 8



Como han respondido otros, los "estándares" dejan la mayoría de los detalles como "implementación definida" y solo establecen que el tipo "char" está al menos en "char_bis", y que "char <= short <= int <= long < = largo largo "(float y double son bastante consistentes con los estándares de punto flotante de IEEE, y el doble largo suele ser igual al doble, pero puede ser más grande en implementaciones más actuales).

Parte de las razones para no tener valores muy específicos y exactos es que los lenguajes como C / C ++ fueron diseñados para ser portátiles a una gran cantidad de plataformas de hardware, incluidos los sistemas informáticos en los que el tamaño de la palabra "char" puede ser de 4 bits o 7 bits, o incluso algún valor distinto de las computadoras "8/16- / 32- / 64-bit" a las que está expuesto el usuario promedio de computadoras domésticas. (El tamaño de palabra aquí significa la cantidad de bits de ancho en que normalmente funciona el sistema. Nuevamente, no siempre son de 8 bits como los usuarios de computadoras personales pueden esperar).

Si realmente necesita un objeto (en el sentido de una serie de bits que representan un valor integral) de un número específico de bits, la mayoría de los compiladores tienen algún método para especificar eso; Pero generalmente no es portátil, incluso entre compiladores hechos por la compañía de ame pero para diferentes plataformas. Algunos estándares y prácticas (especialmente limitan.h y similares) son lo suficientemente comunes como para que la mayoría de los compiladores tengan soporte para determinar el tipo de ajuste óptimo para un rango específico de valores, pero no el número de bits utilizados. (Es decir, si sabe que necesita mantener valores entre 0 y 127, puede determinar que su compilador soporta un tipo "int8" de 8 bits que será lo suficientemente grande como para mantener el rango completo deseado, pero no algo como un tipo "int7" que sería una coincidencia exacta para 7 bits.)

Nota: muchos paquetes fuente * Un * x utilizaron el script "./configure" que probará las capacidades del compilador / sistema y generará un Makefile y config.h adecuados. Puede examinar algunos de estos scripts para ver cómo funcionan y cómo prueban las capacidades del comiler / sistema, y ​​seguir su ejemplo.




unsigned char bits = sizeof(X) << 3;

donde X es un char , int , long , etc. le dará el tamaño de X en bits.




Me doy cuenta de que todas las demás respuestas aquí se han centrado casi exclusivamente en tipos integrales, mientras que el interrogador también preguntó sobre los puntos flotantes.

No creo que el estándar C ++ lo requiera, pero los compiladores para las plataformas más comunes en estos días generalmente siguen el estándar IEEE754 para sus números de punto flotante. Este estándar especifica cuatro tipos de punto flotante binario (así como algunos formatos BCD, que nunca he visto soporte en compiladores de C ++):

  • Media precisión (binario 16) - significando de 11 bits, rango de exponente -14 a 15
  • Precisión simple (binario 32): significado de 24 bits, rango de exponente -126 a 127
  • Doble precisión (binario 64) - significando de 53 bits, rango de exponente -1022 a 1023
  • Precisión cuádruple (binario128) - significando de 113 bits, rango de exponente -16382 a 16383

¿Cómo se relaciona esto con los tipos de C ++, entonces? Generalmente el float usa precisión simple; por lo tanto, sizeof(float) = 4 . Luego, el double utiliza la precisión doble (creo que esa es la fuente del nombre double ), y el long double puede ser la precisión doble o cuádruple (es cuádruple en mi sistema, pero en los sistemas de 32 bits puede ser doble). No conozco ningún compilador que ofrezca puntos flotantes de media precisión.

En resumen, este es el habitual:

  • sizeof(float) = 4
  • sizeof(double) = 8
  • sizeof(long double) = 8 o 16



Puede utilizar variables proporcionadas por bibliotecas como OpenGL , Qt , etc.

Por ejemplo, Qt provides qint8 (se garantiza que es de 8 bits en todas las plataformas compatibles con Qt), qint16, qint32, qint64, quint8, quint16, quint32, quint64, etc.




Hay cuatro tipos de enteros basados ​​en el tamaño:

  • entero corto: 2 bytes
  • entero largo: 4 bytes
  • long long integer: 8 byte
  • entero: depende del compilador (16 bits, 32 bits o 64 bits)



Related


Tags

c++   c++-faq