c++ - tipos - unsigned int para que sirve




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

1) Tabla N1 en el artículo " Los problemas olvidados del desarrollo de programas de 64 bits "

2) " Modelo de datos "

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.


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.


Como se mencionó el tamaño debe reflejar la arquitectura actual. Podrías tomar un pico en limits.h si quieres ver cómo maneja las cosas tu compilador actual.


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

El estándar de C ++ lo dice así:

3.9.1, §2:

Hay cinco tipos de enteros con signo: "char firmado", "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. Las entradas simples tienen el tamaño natural sugerido por la arquitectura del entorno de ejecución (44); Los otros tipos de enteros con signo se proporcionan para satisfacer necesidades especiales.

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

La conclusión: depende de la arquitectura en la que estés trabajando. Cualquier otra suposición es falsa.


El estándar de C ++ no especifica el tamaño de los tipos integrales en bytes, pero especifica rangos mínimos que deben ser capaces de mantener. Puede inferir el tamaño mínimo en bits desde el rango requerido. Puede deducir el tamaño mínimo en bytes a partir de eso y el valor de la macro CHAR_BIT que define el número de bits en un byte (en todas las plataformas menos oscuras, 8, y no puede ser menor que 8).

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

Los rangos mínimos requeridos por el estándar (página 22) son:

y rangos de tipo de datos en MSDN :

  1. signed char : -127 a 127 (nota, no -128 a 127; esto admite plataformas de signo y magnitud de complemento 1)
  2. unsigned char : 0 a 255
  3. char "normal": el mismo rango que el signed char o el unsigned char , implementation-defined
  4. signed short : -32767 a 32767
  5. unsigned short : 0 a 65535
  6. signed int : -32767 a 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 : 0 a 18446744073709551615

Una implementación de C ++ (o C) puede definir el tamaño de un tipo en bytes tamaño de sizeof(type) a cualquier valor, siempre que

  1. la expresión sizeof(type) * CHAR_BIT evalúa a un número de bits lo suficientemente alto como para contener los rangos requeridos, y
  2. el orden del tipo sigue siendo válido (por ejemplo, sizeof(int) <= sizeof(long) ).

Los rangos reales específicos de la implementación se pueden encontrar en el encabezado <limits.h> en C, o <climits> en C ++ (o mejor aún, std::numeric_limits en el std::numeric_limits <limits> ).

Por ejemplo, así es como encontrarás el rango máximo para int :

DO:

#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();

Existe un estándar y se especifica en los diversos documentos de estándares (ISO, ANSI y demás).

Wikipedia tiene una gran página que explica los distintos tipos y la cantidad máxima que pueden almacenar: Integer in Computer Science.

Sin embargo, incluso con un compilador de C ++ estándar, puede encontrarlo 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;
}

La documentación para std::numeric_limits se puede encontrar en std::numeric_limits . Incluye una gran cantidad de otros comandos que puede llamar para averiguar los distintos límites. Se puede usar con cualquier tipo arbitrario que transmita un tamaño, por ejemplo, std :: streamsize.

La respuesta de John contiene la mejor descripción, ya que están garantizadas. Independientemente de la plataforma en la que se encuentre, hay otra buena página que explica con más detalle cuántos bits DEBE contener cada tipo: tipos int , que se definen en la norma.

¡Espero que esto ayude!


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.


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.


Puedes usar:

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

datatype = int , long int etc. Podrá ver el tamaño del tipo de datos que escriba.


Se 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;
...

Entonces, cuando transferimos el código a una máquina diferente donde en realidad el tamaño de int largo es 4, podemos simplemente redefinir la ocurrencia individual de int.

typedef long int int32;

int32 i;
int32 j;
...

Si necesita tipos de tamaño fijo, use tipos como uint32_t (entero sin signo de 32 bits) definidos en stdint.h . Se especifican en C99 .


En una máquina de 64 bits:

int: 4
long: 8
long long: 8
void*: 8
size_t: 8


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.





c++-faq