Lo que hace el estándar de C++ indicar el tamaño de int, long tipo?

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

Pero hay algunos estándares de 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

Traté de encontrar, sin mucho éxito, la información fiable que indique el tamaño de char, short, int, long, double, float (y otros tipos no creo que de) bajo diferentes arquitecturas y compiladores.

  • no es por elección… hay tantas arquitecturas apoyo que necesita ser flexible.
  • Ver: stackoverflow.com/questions/271076/…
  • Por qué no eliminar todos los vagos tipos, y normalizar todos definitiva de la longitud en bits de los tipos por ejemplo, int32_t, uint32_t, int64_t etc.
  • De hecho, es bastante difícil estandarizar algo como esto. A diferencia de Java, donde estas cosas son constantes debido a la forma en la JVM obras, C/C++, esencialmente, a cumplir con el sistema que se corrió en sin ningún tipo de lujo-pancy capas de abstracción (por lo menos no tantas como con Java) en el medio. Si el tamaño de la int es importante que uno puede utilizar int16_t, int32_t y int64_t (necesitan el iostream incluyen, por que si mal no recuerdo). Lo bueno de este que int64_t no debería tener problemas en un sistema de 32 bits (esto impactará en el rendimiento, sin embargo).
  • En realidad son definidos en <cstdint>, no <iostream>.
  • Aunque el OP específicamente se pregunta también sobre los números de punto flotante, ninguna de las respuestas de la dirección que…

InformationsquelleAutor Jérôme | 2009-02-26

24 Kommentare

  1. 668

    El C++ estándar no especifica el tamaño de los tipos integrales en bytes, pero especifica mínima rangos de ellos debe ser capaz de mantener. Se puede inferir mínimo tamaño en bits de la gama. Se puede inferir mínimo tamaño en bytes de eso y el valor de la CHAR_BIT macro que define el número de bits en un byte. En todos, pero la más oscura de las plataformas es de 8, y no puede ser inferior a 8. Eso es porque debe ser lo suficientemente grande para contener «los ocho bits unidades de código de Unicode UTF-8
    la codificación de la forma».

    Una restricción adicional para char es que su tamaño es siempre de 1 byte, o CHAR_BIT bits (de ahí el nombre). Esto se afirma explícitamente en la norma.

    El estándar de C es un normativo de referencia para el estándar de C++, por lo que aunque no se el estado de estos requisitos de forma explícita, C++ requiere el mínimo rangos de requerido por el estándar de C (página 22), que son los mismos que los de Tipo de Datos a Intervalos en MSDN:

    1. signed char: -127 a 127 (nota, no -128 a 127; esto se adapta a 1-complemento y el signo y la magnitud de las plataformas)
    2. unsigned char: 0 a 255
    3. «normal» char: rango de signed char o unsigned char, la aplicación definida por el
    4. signed short :- 32767 32767
    5. unsigned short: 0 a 65535
    6. signed int :- 32767 32767
    7. unsigned int: 0 a 65535
    8. signed long: -2147483647 a 2147483647
    9. unsigned long: 0 a 4294967295
    10. signed long long: -9223372036854775807 a 9223372036854775807
    11. unsigned long long: De 0 a 18446744073709551615

    C++ (o C) la aplicación puede definir el tamaño de un tipo de datos en bytes sizeof(type) a cualquier valor, mientras

    1. la expresión sizeof(type) * CHAR_BIT se evalúa como un número de bits de alta suficiente para contener requiere rangos, y
    2. el orden de tipo sigue siendo válida (por ejemplo,sizeof(int) <= sizeof(long)).

    Poner todo esto junto, tenemos la garantía de que:

    • char, signed char, y unsigned char son al menos 8 bits
    • signed short, unsigned short, signed int, y unsigned int al menos 16 bits
    • signed long y unsigned long son al menos 32 bits
    • signed long long y unsigned long long son al menos 64 bits

    No se hace ninguna garantía sobre el tamaño de float o double excepto que double al menos con tanta precisión como float.

    La implementación real-rangos específicos se pueden encontrar en <limits.h> de cabecera en C, o <climits> en C++ (o incluso mejor, con plantilla std::numeric_limits en <limits> encabezado).

    Por ejemplo, esta es la forma en que encontrar el valor máximo de la gama de int:

    C:

    #include <limits.h>
    const int min_int = INT_MIN;
    const int max_int = INT_MAX;

    C++:

    #include <limits>
    const int min_int = std::numeric_limits<int>::min();
    const int max_int = std::numeric_limits<int>::max();
    • Más bien, el estándar de C++ usa la palabra byte significa «1 char«, y no el significado usual.
    • Sería bueno si esta respuesta fue actualizado con el C++11 rangos, que creo que han cambiado (aunque no estoy seguro).
    • No creo que los rangos han cambiado, aunque precisa de los tipos de C99 inttypes.h fueron añadidos (por ejemplo, int64_t), pero es fácil determinar el tamaño de estos.
    • Yo había cambiado los rangos negativos. Alguien me puede decir por qué mi cambio fue revertida?
    • Leer la respuesta (punto 1 de la nota entre paréntesis), o el estándar real de la redacción (vinculado en la respuesta). C estándar con capacidad para 1 complemento a las arquitecturas, los cuales tienen diferentes representación de las más extendidas en complemento a 2. Mínimo garantizado rangos casi siempre difieren de las distribuciones reales de una aplicación proporciona.
    • ¿Cómo puedo obtener max, min límites para unsigned long long?
    • En C++, std::numeric_limits<unsigned long long>::min/max(), en C, ULLONG_MIN/MAX (C99 sólo).
    • Nota: estos son MÍNIMOS.
    • B no menciona nada sobre el doble en su respuesta. Por favor, puedes actualizar tu respuesta para las variables de punto flotante?
    • De punto flotante es un conjunto adicional hervidor de pescado, fácilmente duplicar los puestos de tamaño.
    • El `documento estándar» vinculado a es C.
    • B signed int : – 2.147.483.648 a 2.147.483.647, desde el Tipo de Datos a los Rangos de MSDN
    • esto es para MSVC++específicos de doc, que sólo admite el complemento a dos plataformas, la norma admite queridos complementar así.
    • Sólo para un compilador específico para una arquitectura específica. Este post es mostrar C++ mínimo rangos, no Visual Studio rangos en la arquitectura x64.
    • El poco acerca firmado char tipos está en el intervalo [-127..127] era la correcta, a partir de la fecha de esta respuesta. Nuevos estándares de C++, sin embargo, han añadido un poco de lenguaje para asegurarse de que un char puede representar (al menos) de 256 valores distintos. Tenga en cuenta que [-127..127] es sólo 255 valores distintos. Si su char tipo de la firma, que debe ser capaz de representar uno más valor fuera de este rango, por lo que usted está garantizado para tener -128. Pero esto es específico de char y no el de otros tipos integrales. Y no sé si la C tiene un requisito similar.
    • El [-127…127] todavía es válida, y por implicación a todos los de la versión de C++ requiere 256 valores distintos. Es simplemente siempre ha sido vaga acerca de lo que el pasado es el valor. En algunas arquitecturas es -128, en algunos es de 128, en algunos es -0… En teoría también podría ser +∞. O 1000 (con valores 128-999 sin representación). C++ especificaciones no dice.
    • Pato: «todas las versiones de C++ requiere 256 valores distintos [para signed char tipos]» No, eso no era cierto, hasta que se fija en el más reciente de C++ especificaciones. Los mayores especificaciones permitido signed char tipos que poseen patrones de bits que no se asignan a un número, por lo que a ellos les faltaba el requisito de que no ser de 256 valores distintos. «Para unsigned tipos de caracteres, todos los posibles patrones de bits de la representación de valor representar los números. Estos requisitos no a otros tipos.»
    • Fascinante, yo no había pensado en un «sin número» del patrón. Hace sentido.
    • ya no más.
    • Pero no es este documento estándar para C99 y no en C++?
    • C++ «importaciones» algunas características de C99 (stdint.h/cstdint es uno de ellos), pero creo que no hay un verdadero estándar de C++ documento abiertamente disponibles, de modo que todo lo que tengo.
    • href=»http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4659.pdf» >open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4659.pdf
    • parece que sólo se pospone a C99 de especificaciones, por lo que C99 enlace está ok
    • No entiendo esa frase.
    • El estándar de C++ hace referencia el estándar de C, no incluye todos los requisitos del mismo (ver «referencias Normativas»).
    • Tenga en cuenta que C++20 ahora exige dos complementar para firma de los tipos enteros.

  2. 233

    Para sistemas de 32 bits, el ‘de facto’ estándar es ILP32 — que es, int, long y puntero son todas las cantidades de 32 bits.

    Para sistemas de 64 bits, el principal Unix ‘de facto’ estándar es LP64 — long y el puntero de 64 bits (pero int es de 32 bits). El Windows de 64 bits estándar es LLP64 — long long y el puntero de 64 bits (pero long y int de 32 bits).

    A la vez, algunos sistemas Unix utiliza un ILP64 organización.

    Ninguna de estas normas de facto es legislado por el C estándar (ISO/IEC 9899:1999), pero a todos se les permite por ella.

    Y, por definición, sizeof(char) es 1, sin perjuicio de la prueba en el Perl script configure.

    Nota que había máquinas (Crays) donde CHAR_BIT era mucho mayor que 8. Eso significaba que, si mal no recuerdo, que sizeof(int) también fue de 1, debido a que ambos char y int eran de 32 bits.

    • +1 para decir cómo las cosas realmente son en los casos que importa a la mayoría, en lugar de cómo son las cosas en la teoría. Si desea usar int de 32 bits, si quieres 64 bits, el uso a largo tiempo. Si desea nativo size_t. Evitar el «plano» de largo, ya que varía. Que debería funcionar para la mayoría de las aplicaciones.
    • +1 para la respuesta. @Eloff: por el contrario… si desea 32 bits uso [u]int32_t o similar, si desea 64 bits uso [u]int64_t… si usted no tiene un encabezado para ellos, descargar o hacer una, preferiblemente con tiempo de compilación, selección de tipos estáticos o afirmaciones para comprobar el tamaño. pubs.opengroup.org/onlinepubs/009695299/basedefs/stdint.h.html Si la precisa tamaños no son tan importantes y que solo están al menos tan grande, entonces su consejo es para el común de los modernos PC/plataformas de servidor.
    • Tenga en cuenta que no es simplemente viejo cray máquinas que tienen CHAR_BIT > 8. por ejemplo, DSPs a menudo tienen CHAR_BIT de 16 o 32. (ver, por ejemplo, estos)
    • Gracias por el enlace. Es muy útil contar con modernos sistemas actuales identificados para el bicho raro de los casos. Por curiosidad, ¿cuál es el conjunto de códigos en esas máquinas? Si el código es UTF-16, a continuación, 0xFFFF no es un carácter válido, y si el código es un ISO 8859-x código establece, a continuación, de nuevo 0xFFFF no es un carácter válido (códigos de caracteres de 0x00 a 0xFF son válidos). Todavía no estoy convencido de que hay un problema de detección de EF, pero sin duda hay espacio para la precaución, y, probablemente, para la escritura y el uso de una función int get_char(FILE *fp, char *c) que devuelve EOF o 0 y establece *c.
    • Un desagradable capricho de uint32_t es que sólo se comporta en los cálculos como un entero de tipo de plataformas donde int es de 32 bits o más pequeños. Creo que no hay ninguna razón por qué un estándar de lenguaje no debería ser tipos que definen los comportamientos independiente del tamaño de int, pero a menos que o hasta que C lo hace, el código que se supone debe ser de tipo int independientes del tamaño será torpe y difícil de leer.
    • Hacerlo invalidaría todo el entero de las reglas de la promoción. Compatibilidad significa que es poco probable que se produzca antes de que C es olvidado, y que aún no se vislumbra.
    • Me refería a proporcionar nuevo tipos, algo que en mi humilde opinión debe suceder para C si los procesadores de 64 bits va a ser capaz de ejecutar código de forma eficiente sin tener que gastar opcode bits de los operandos de tamaño de selección (haciendo int de 64 bits de romper una gran cantidad de código, pero si int es de 64 bits, a continuación, los compiladores deben ofrecer determinista del comportamiento cuando se desborda un int32, lo que limita las optimizaciones).
    • Que no parece ser el caso en C11, donde uintN_t se requiere para ser un entero sin signo tipo de exactamente N bits
    • Compatibilidad con versiones anteriores simplemente requieren que los tipos existentes sigan trabajando como lo hacen. Si C fueron a la definición de nuevos tipos de uwrapN_t que, en las implementaciones de que las define, estaban obligados a obedecer ciertas reglas que, naturalmente, sería obedecido por un uintN_t en sistemas donde int fue de N bits, y se especificó que los compiladores deben rechazar cualquier programa que utiliza estos tipos de tal manera que las reglas no puede ser satisfecha con los tipos disponibles para el compilador, por lo que la compatibilidad problema hay con eso?
    • Un sistema de 64 bits podría definir uwrap32_t o no a su ocio. El código que utiliza uwrap32_t se puede ejecutar directamente en la versión de 64 bits de los compiladores que soporte ese tipo; si es necesario para ejecutar código en los compiladores que no lo apoyan, el uso de uwrap32_t en lugares donde el comportamiento de ajuste que realmente importa haría más fácil para encontrar y arreglar esos lugares que haría uso de uint32_t en todas partes.
    • Lo que la «compatibilidad» de los problemas con estos tipos no sería menor en comparación con la muy real de compatibilidad con versiones anteriores de los problemas que plantea el enorme cuerpo de código que necesita un tipo que se comporta como una expresión algebraica anillo de enteros congruentes mod 4294967296, y la falta de tales tipos de plataformas donde «int» es mayor que el de 32 bits?
    • C11 requiere que, dado uint32_t x=1,y=2; el valor de x-y debe ser 4294967295 en las plataformas donde el «int» es de 32 bits o más pequeños, y -1 en las plataformas donde el «int» es de 33 bits o más. Además, se requiere que x*y debe ser evaluado usando aritmética modular para todos los valores de x e y si «int» es de 32 bits o más pequeños, y la aritmética convencional si 65 bits o más, pero no se establecen requisitos en lo que pueda suceder con los grandes valores de x e y si «int» es de 33 a 64 bits.
    • No sólo la vieja Crays, es común que los DSP partes para la más pequeña unidad direccionable de memoria mucho mayor que 8 bits, los Dispositivos Analógicos SHARC, por ejemplo, sizeof (char) == sizeof (short) == sizeof (int) == 1, y no define uint8_t o uint16_t porque ninguno de estos tipos existen. Una grata sorpresa al intentar puerto de algunos SPI mensaje código de análisis! Algunas de las TI cosas que hace la misma cosa, y hay por lo menos algunas partes con no poder de dos longitudes de palabra (24 bits IIRC).

  3. 88

    En la práctica no existe tal cosa. A menudo, usted puede esperar std::size_t para representar el unsigned nativo de enteros de tamaño en la arquitectura actual. es decir, 16-bit, 32-bit o 64-bit, pero no es siempre el caso, como se señaló en los comentarios a esta respuesta.

    Tan lejos como todos los otros tipos integrados vaya, realmente depende del compilador. He aquí dos extractos tomados de la actual borrador de trabajo de última estándar de C++:

    Hay cinco estándar firmado tipos enteros : signed char, short int, int, long int y long long int. En esta lista, cada tipo ofrece, al menos, tanto de almacenamiento como de aquellos que lo precede en la lista.

    Para cada uno de los estándares firmado los tipos integer, existe un correspondiente (pero diferente), estándar de tipo de entero sin signo: unsigned char, unsigned short int, unsigned int, unsigned long int o unsigned long long int, cada uno de los cuales ocupa la misma cantidad de almacenamiento y tiene los mismos requisitos de alineación.

    Si quieres puedes estáticamente (en tiempo de compilación) afirman que el tamaño de estos tipos fundamentales. Se enviará una alerta a la gente a pensar sobre la portabilidad de su código, si el tamaño de los supuestos de cambio.

    • buen post. otra cosa que se requiere es el siguiente bit menos-tamaños (documentado en c89 / c99, junto con los límites.h y tomado por c++): char >=8, a corto y int >=16, long >=32 .
    • También, en un AVR de 8 bits de la plataforma de size_t no va a ser de 8 bits, pero 16, porque el puntero int y tamaños son de 16 bits. Por lo que el procesador de datos nativos de tamaño no está relacionado con size_t.
  4. 79

    No es estándar.

    C90 norma requiere que

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

    Estándar C99 requiere que

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

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

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

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

    Si usted está preocupado con la portabilidad, o desea que el nombre del tipo que refleja el tamaño, se puede ver en el encabezado de <inttypes.h>, donde las macros siguientes están disponibles:

    int8_t
    int16_t
    int32_t
    int64_t

    int8_t está garantizado para ser de 8 bits, y int16_t está garantizado a ser de 16 bits, etc.

    • Menor pequeñeces: ¿de dónde viene el estándar decir sizeof(long) < sizeof(long long) como contraposición a la simétrica sizeof(long) <= sizeof(long long)?
    • ver C99 5.2.4.2.1 – los Tamaños de los tipos enteros. minsizeof(int)==16-bits, minsizeof(largo)==32-bits, minsizeof(largo)==64-bits. Así que yo creo que están a la derecha en la <= como no maxsizeof(tipo) se especifica.
    • Del mismo modo sizeof(float) <= sizeof(double) <= sizeof(long double). De acuerdo a C99 7.12 párrafo 2.
    • …en plataformas que tenía exactamente esas ancho de representaciones…
  5. 38

    Si usted necesita tamaño fijo tipos de, tipos de uso como uint32_t (entero sin signo de 32 bits), definido en el stdint.h. Están especificados en C99.

    • Ellos se especifican, pero no es necesario.
    • ¿Qué plataformas no lo incluyen?
    • Cualquier plataforma que no tienen ellos en la forma requerida. Una plataforma que ha CHAR_BIT == 16, por ejemplo, no han int8_t. Cualquier plataforma utilizando el complemento a dos no han alguna de ellos (como el complemento a dos es requerido por la norma).
  6. 35

    Actualizado: C++11 traído los tipos de TR1 oficialmente en la norma:

    • long long int
    • unsigned long long int

    Y el «tamaño» de los tipos de <cstdint>

    • int8_t
    • int16_t
    • int32_t
    • int64_t
    • (y el unsigned homólogos).

    Además de obtener:

    • int_least8_t
    • int_least16_t
    • int_least32_t
    • int_least64_t
    • Más el unsigned contrapartes.

    Estos tipos representan el entero más pequeño que los tipos con al menos el número especificado de bits. Asimismo, hay el «más rápido» tipos enteros con al menos el número especificado de bits:

    • int_fast8_t
    • int_fast16_t
    • int_fast32_t
    • int_fast64_t
    • Más el unsigned versiones.

    Lo «rápido» significa, en todo caso, hasta la implementación. No es necesario ser el más rápido para todos los efectos de cualquiera.

    • Esto es parte de C++11 estándar ahora.
    • «rápido» sólo significa adaptarse a la arquitectura de hardware. Si los registros son de 16 bits, entonces int_fast8_t es un valor de 16 bits. Si los registros son de 32 bits, entonces int_fast8_t y int_fast16_t ambos son valores de 32 bits. etc. Ver C99 sección 7.18.1.3 párrafo 2.
  7. 19

    La El Estándar De C++ , y dice así:

    3.9.1, §2:

    Hay cinco entero con signo tipos :
    «signed char», «short int», «int»,
    «long int», y «long long int». En
    esta lista, cada tipo ofrece, al menos,
    tanto espacio de almacenamiento como los anteriores que
    en la lista. Llanura enteros tienen el
    de tamaño natural, sugerido por el
    la arquitectura de la ejecución
    medio ambiente (44); la otra, firmado
    los tipos enteros se proporcionan para satisfacer
    necesidades especiales.

    (44) que es, lo suficientemente grande como para contener
    cualquier valor en el rango de INT_MIN y
    INT_MAX, tal como se define en el encabezado
    <climits>
    .

    La conclusión: depende de la arquitectura que se está trabajando. Cualquier otra suposición es falsa.

  8. 12

    Nope, no hay un estándar para el tipo de tamaños. Estándar sólo requiere que:

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

    La mejor cosa que usted puede hacer si desea variables de tamaños fijos es el uso de macros como este:

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

    Entonces usted puede utilizar la PALABRA para definir sus variables. No es que no me gusta esto, pero es la la mayoría de los portátiles manera.

    • El problema es que el término se extendió a todo el programa en áreas que no son realmente depende de un tamaño fijo (vistazo a algunos de códigos de windows). Como descubrí al pasar de 16 bits a 32 bits del sistema que terminan con el mismo problema que la PALABRA se pretende resolver.
    • Por supuesto, usted debe usar la PALABRA sólo cuando usted necesita un tamaño fijo, variable, al igual que cuando usted está leyendo/escribiendo desde/a un archivo. Si una pieza de código no es muy dependiente de un tamaño fijo, entonces usted debe utilizar la normal «int» variables.
    • La mejor cosa que usted puede hacer para conseguir portátil tamaños deben #include <boost/cstdint.hpp>
  9. 10

    Nos permite definir un sinónimo para el tipo para que podamos crear nuestro propio «estándar».

    En una máquina en la que sizeof(int) == 4, podemos definir:

    typedef int int32;
    
    int32 i;
    int32 j;
    ...

    Así que cuando la transferencia de código para una máquina diferente, donde en realidad el tamaño de long int es de 4, podemos redefinir la ocurrencia de int.

    typedef long int int32;
    
    int32 i;
    int32 j;
    ...
    • Que no es necesario dada la cabecera estándar <stdint.h> (C99 y más tarde, y sea cual sea el estándar de C++ adoptado la C99 versión de la librería de C).
  10. 8

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

    • Sin embargo, el cumplimiento con el estándar IEEE 754 (aka IEC 559) es opcional en C++ (probablemente C también, pero no estoy seguro). Ver std::numeric_limits::is_iec559.
    • Entonces no has visto a TI compilador para TMS320C28xx Dsp, donde double tiene el mismo tamaño que float (y int la misma como char, ambos son de 16 bits). Pero ellos tienen un sistema de 64 bits long double.
  11. 7

    No hay un estándar y que se especifica en los diversos documentos de normas (ISO, ANSI y otras cosas).

    Wikipedia tiene una gran página de explicar los diferentes tipos y el máximo que puede almacenar:
    Entero en Ciencias de la computación.

    Sin embargo, incluso con un estándar de C++, el compilador puede encontrar con relativa facilidad utilizando el siguiente fragmento de código:

    #include <iostream>
    #include <limits>
    
    
    int main() {
        //Change the template parameter to the various different types.
        std::cout << std::numeric_limits<int>::max() << std::endl;
    }

    Documentación para std::numeric_limits se puede encontrar en la Roguewave. Incluye una gran cantidad de otros comandos que usted puede llamar para averiguar los diferentes límites. Esto puede ser usado con cualquier tipo arbitrario que transmite tamaño, por ejemplo std::streamsize.

    La respuesta de juan contiene la mejor descripción, como los que están garantizados para mantener. No importa qué plataforma estás, no es otra buena página que entra en más detalles en cuanto a la cantidad de bits de cada tipo DEBE contener: int tipos, los cuales están definidos en el estándar.

    Espero que esto ayude!

  12. 7

    Puede utilizar:

    cout << "size of datatype = " << sizeof(datatype) << endl;

    datatype = int, long int etc.
    Usted será capaz de ver el tamaño para cualquier tipo de datos que usted escriba.

  13. 7

    Cuando se trata de construir en los tipos para diferentes arquitecturas y diferentes compiladores sólo tiene que ejecutar el siguiente código en su arquitectura con su compilador para ver lo que se emite. A continuación se muestra mi Ubuntu 13.04 (con muchas Ganas de cola Anillada) de 64 bits g++4.7.3 salida. También tenga en cuenta lo que fue contestado por debajo de los cuales es por eso que se ordena la salida como tal:

    «Hay cinco estándar firmado tipos enteros: signed char, short int, int, long int y long long int. En esta lista, cada tipo ofrece, al menos, tanto de almacenamiento como de aquellos que lo precede 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
    • sizeof(char) no debe ser incluido.
  14. 3

    Como se ha mencionado el tamaño debe reflejar la arquitectura actual. Usted podría tomar un pico alrededor de limits.h si usted quiere ver cómo su compilador actual es el manejo de las cosas.

    • Gracias, pero me gustaría saber los tamaños de achitectures no tengo myselft (como la de 64 bits). Este tutorial sólo se habla de 32bits achitectures…
  15. 2

    Como otros han contestado, los «estándares» que se vayan todos la mayoría de los detalles de implementación de la «definido» y el único estado que el tipo «char» es en leat «char_bis» de ancho, y que «char <= corto <= int <= mucho <= long long» (float y double son bastante consistentes con los estándares IEEE de punto flotante de normas y long double es típicamente mismo como el doble … pero puede ser mayor en más de las implementaciones actuales).

    Parte de las razones de no tener muy específico y exacto de los valores es porque lenguajes de programación como C/C++ fueron diseñados para ser portátiles a un gran número de plataformas de hardware–Incluyendo sistemas informáticos en los que el «char» palabra-tamaño puede ser de 4 bits o 7-bits, o incluso algún valor distinto de la «8-/16-/32-/64-bits» los equipos que el usuario medio de la computadora del usuario está expuesto. (Palabra-del tamaño del significado del número de bits que el sistema opera normalmente en, de Nuevo, no es siempre de 8 bits como el ordenador de casa que los usuarios pueden esperar.)

    Si usted 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 de especificación de eso; Pero generalmente no es portátil, incluso entre los compiladores realizados por la misma empresa, pero para diferentes plataformas. Algunos de los estándares y prácticas (especialmente límites.h y similares) son bastante comunes que la mayoría de los compiladores tendrá soporte para determinar el mejor tipo de ajuste para un rango específico de valores, pero no el número de bits utilizados. (Es decir, si usted sabe que usted necesita para contener valores entre 0 y 127, se puede determinar que su compilador soporta un «int8» tipo de 8-bits, lo que va a ser de gran tamaño suficiente para contener toda la gama deseada, pero no algo así como un «int7» tipo de la que sería una coincidencia exacta de 7-bits).

    Nota: Muchas de las naciones unidas*x fuente de los paquetes utilizados «./configurar la secuencia de comandos» que probará el compilador/capacidades del sistema y la salida de un adecuado archivo Makefile y config.h. Usted puede examinar algunas de estas secuencias de comandos para ver cómo funcionan y cómo se sonda de la comiler/capacidades del sistema, y seguir su ejemplo.

  16. 1

    Si usted está interesado en un puro C++ solución, hice uso de plantillas y sólo el estándar de C++ de código para definir los tipos en tiempo de compilación basado en su poco tamaño.
    Esto hace que la solución portable a través de los compiladores.

    La idea detrás de esto es muy simple: Crear una lista que contiene los tipos de datos char, int, short, long, long long (signed y unsigned versiones) y la exploración de la lista y por el uso de numeric_limits plantilla seleccione el tipo con un tamaño dado.

    Incluyendo este encabezado se 8 tipo stdtype::int8, stdtype::int16, stdtype::int32, stdtype::int64, stdtype::uint8, stdtype::uint16, stdtype::uint32, stdtype::uint64.

    Si algún tipo no puede ser representado será evaluado para stdtype::null_type también declaró en ese encabezado.

    EL CÓDIGO SIGUIENTE SE DAN SIN GARANTÍA, POR FAVOR VERIFIQUE LA MISMA.

    SOY NUEVO EN METAPROGRAMACIÓN DEMASIADO, SIÉNTASE LIBRE DE EDITAR Y CORREGIR ESTE CÓDIGO.

    Probado con DevC++ (para una versión de gcc en torno a 3,5)

    #include <limits>
    
    namespace stdtype
    {
        using namespace std;
    
    
        /*
         * THIS IS THE CLASS USED TO SEMANTICALLY SPECIFY A NULL TYPE.
         * YOU CAN USE WHATEVER YOU WANT AND EVEN DRIVE A COMPILE ERROR IF IT IS 
         * DECLARED/USED.
         *
         * PLEASE NOTE that C++ std define sizeof of an empty class to be 1.
         */
        class null_type{};
    
        /*
         *  Template for creating lists of types
         *
         *  T is type to hold
         *  S is the next type_list<T,S> type
         *
         *  Example:
         *   Creating a list with type int and char: 
         *      typedef type_list<int, type_list<char> > test;
         *      test::value         //int
         *      test::next::value   //char
         */
        template <typename T, typename S> struct type_list
        {
            typedef T value;
            typedef S next;         
    
        };
    
    
    
    
        /*
         * Declaration of template struct for selecting a type from the list
         */
        template <typename list, int b, int ctl> struct select_type;
    
    
        /*
         * Find a type with specified "b" bit in list "list"
         *
         * 
         */
        template <typename list, int b> struct find_type
        {   
            private:
                //Handy name for the type at the head of the list
                typedef typename list::value cur_type;
    
                //Number of bits of the type at the head
                //CHANGE THIS (compile time) exp TO USE ANOTHER TYPE LEN COMPUTING
                enum {cur_type_bits = numeric_limits<cur_type>::digits};
    
            public:
                //Select the type at the head if b == cur_type_bits else
                //select_type call find_type with list::next
                typedef  typename select_type<list, b, cur_type_bits>::type type;
        };
    
        /*
         * This is the specialization for empty list, return the null_type
         * OVVERRIDE this struct to ADD CUSTOM BEHAVIOR for the TYPE NOT FOUND case
         * (ie search for type with 17 bits on common archs)
         */
        template <int b> struct find_type<null_type, b>
        {   
            typedef null_type type;
    
        };
    
    
        /*
         * Primary template for selecting the type at the head of the list if
         * it matches the requested bits (b == ctl)
         *
         * If b == ctl the partial specified templated is evaluated so here we have
         * b != ctl. We call find_type on the next element of the list
         */
        template <typename list, int b, int ctl> struct select_type
        {   
                typedef  typename find_type<typename list::next, b>::type type; 
        };
    
        /*
         * This partial specified templated is used to select top type of a list
         * it is called by find_type with the list of value (consumed at each call)
         * the bits requested (b) and the current type (top type) length in bits
         *
         * We specialice the b == ctl case
         */
        template <typename list, int b> struct select_type<list, b, b>
        {
                typedef typename list::value type;
        };
    
    
        /*
         * These are the types list, to avoid possible ambiguity (some weird archs)
         * we kept signed and unsigned separated
         */
    
        #define UNSIGNED_TYPES type_list<unsigned char,         \
            type_list<unsigned short,                           \
            type_list<unsigned int,                             \
            type_list<unsigned long,                            \
            type_list<unsigned long long, null_type> > > > >
    
        #define SIGNED_TYPES type_list<signed char,         \
            type_list<signed short,                         \
            type_list<signed int,                           \
            type_list<signed long,                          \
            type_list<signed long long, null_type> > > > >
    
    
    
        /*
         * These are acutally typedef used in programs.
         * 
         * Nomenclature is [u]intN where u if present means unsigned, N is the 
         * number of bits in the integer
         *
         * find_type is used simply by giving first a type_list then the number of 
         * bits to search for.
         *
         * NB. Each type in the type list must had specified the template 
         * numeric_limits as it is used to compute the type len in (binary) digit.
         */
        typedef find_type<UNSIGNED_TYPES, 8>::type  uint8;
        typedef find_type<UNSIGNED_TYPES, 16>::type uint16;
        typedef find_type<UNSIGNED_TYPES, 32>::type uint32;
        typedef find_type<UNSIGNED_TYPES, 64>::type uint64;
    
        typedef find_type<SIGNED_TYPES, 7>::type    int8;
        typedef find_type<SIGNED_TYPES, 15>::type   int16;
        typedef find_type<SIGNED_TYPES, 31>::type   int32;
        typedef find_type<SIGNED_TYPES, 63>::type   int64;
    
    }
  17. 0
    unsigned char bits = sizeof(X) << 3;

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

    • un char no es siempre de 8 bits, por lo que su expresión no funciona en arquitecturas con los no-8-bit char. Sólo sizeof(type)*CHAR_BIT tiene
    • Incluso si CHAR_BIT están garantizados para ser de 8 bits, << 3 es simplemente un ofuscado manera de escribir * 8 o * CHAR_BIT.
  18. 0

    De Alex B El C++ estándar no especifica el tamaño de los tipos integrales en bytes, pero especifica mínima rangos de ellos debe ser capaz de mantener. Se puede inferir mínimo tamaño en bits de la gama. Se puede inferir mínimo tamaño en bytes de eso y el valor de la CHAR_BIT macro que define el número de bits en un byte (en todos, pero la más oscura de las plataformas es de 8, y no puede ser inferior a 8).

    Una restricción adicional para char es que su tamaño es siempre de 1 byte, o CHAR_BIT bits (de ahí el nombre).

    Rangos mínimo requerido por la norma (página 22) son:

    y el Tipo de Datos a Intervalos en MSDN:

    signed char: -127 a 127 (nota, no -128 a 127; esto se adapta a 1 complemento a las plataformas)
    unsigned char: de 0 a 255
    «plain» char: -127 a 127 0 a 255 (depende del defecto char signedness)
    signed short: – 32767 32767
    unsigned short: 0 a 65535
    signed int: – 32767 32767
    unsigned int: 0 a 65535
    firmado largo: -2147483647 a 2147483647
    unsigned long: 0 a 4294967295
    firmado largo, largo: -9223372036854775807 a 9223372036854775807
    unsigned long long: 0 a 18446744073709551615
    C++ (o C) la aplicación puede definir el tamaño de un tipo de datos en bytes sizeof(tipo) para cualquier valor, mientras

    la expresión sizeof(tipo) * CHAR_BIT devuelve el número de bits suficiente para contener requiere rangos, y
    el orden de tipo sigue siendo válida (por ejemplo, sizeof(int) <= sizeof(long)).
    La implementación real-rangos específicos se pueden encontrar en la cabecera en C o en C++ (o incluso mejor, con plantilla std::numeric_limits en la cabecera).

    Por ejemplo, esta es la forma en que encontrar el máximo rango para int:

    C:

    #include <limits.h>
    const int min_int = INT_MIN;
    const int max_int = INT_MAX;

    C++:

    #include <limits>
    const int min_int = std::numeric_limits<int>::min();
    const int max_int = std::numeric_limits<int>::max();

    Esto es correcto, sin embargo, que también estaban en lo cierto si digo que:
    char : 1 byte
    corto : 2 bytes
    int : 4 bytes
    largo : 4 bytes
    float : 4 bytes
    doble : 8 bytes

    Debido a que las arquitecturas de 32 bits son la predeterminada, y el más utilizado, y han mantenido a estos tamaños estándar desde antes de la era de 32 bits días cuando la memoria disponible menos, y por compatibilidad y estandarización sigue siendo la misma. Incluso los sistemas de 64 bits, tienden a usar estas y tienen extensiones y/o modificaciones.
    Por favor hacer referencia a esta para más información:

    http://en.cppreference.com/w/cpp/language/types

  19. 0

    Me doy cuenta de que todas las otras respuestas aquí, se han centrado casi exclusivamente en los tipos enteros, mientras que el interrogador le preguntó sobre flotante puntos.

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

    • La mitad de precisión (binary16) – 11-bits de mantisa, exponente rango de 14 a 15
    • De precisión simple (binary32) – 24-bits de mantisa, exponente de la gama -126 a 127
    • De doble precisión (binary64) – 53-bits de mantisa, exponente de la gama -1022 a 1023
    • Cuádruple de precisión (binary128) – 113-bits de mantisa, exponente de la gama -16382 a 16383

    ¿Cómo este mapa en C++ tipos, entonces? Generalmente el float utiliza una sola precisión; por lo tanto, sizeof(float) = 4. Luego double uso de doble precisión (creo que ese es el origen del nombre de double), y long double puede ser el doble o el cuádruple de precisión (es cuádruple en mi sistema, pero en sistemas de 32 bits puede ser el doble). No sé de alguno de los compiladores que ofrecen la mitad flotante de precisión de los puntos de.

    En resumen, esto es lo de siempre:

    • sizeof(float) = 4
    • sizeof(double) = 8
    • sizeof(long double) = 8 o 16
    • Es curioso que llegué a esta cuestión como parte de preguntarse por qué Jeff utiliza más bytes que él necesita.
  20. -2

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

    Por ejemplo, Qt proporciona qint8 (garantizados para ser de 8 bits en todas las plataformas soportadas por Qt), qint16, qint32, qint64, quint8, quint16, quint32, quint64, etc.

    • No responde a la pregunta
  21. -8

    En una máquina de 64 bits:

    int: 4
    long: 8
    long long: 8
    void*: 8
    size_t: 8
    • En algunos de 64 bits máquinas int es de 8 bytes, pero el otro no está garantizada. No hay nada que dice que char debe ser sólo 8 bits. Es permitido tener sizeof(void*)==4 a pesar de que es de 64 bits.
  22. -9

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

    • entero corto: 2 bytes
    • entero largo: 4 bytes
    • largo entero largo: de 8 bytes
    • entero: depende del compilador (16 bits, 32 bits o 64 bits)
    • Falso, todos dependen de la arquitectura, con el mínimo de los rangos descritos en una de las otras respuestas. Nada detiene una aplicación para tener short, int y long todos los 32 bits enteros.
    • Ni siquiera le has utilizado los nombres correctos de los tipos. El uso de nombres la palabra clave int, no la palabra «entero».

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea