¿El tamaño de C “int” es de 2 bytes o 4 bytes?

¿Una variable entera en C ocupa 2 bytes o 4 bytes? ¿Cuáles son los factores de los que depende?

La mayoría de los libros de texto dicen que las variables enteras ocupan 2 bytes. Pero cuando ejecuto un progtwig que imprime las direcciones sucesivas de una matriz de enteros, muestra la diferencia de 4.

Sé que es igual a sizeof(int) . El tamaño de un int realmente depende del comstackdor. En el pasado, cuando los procesadores tenían 16 bits, un int era de 2 bytes. En la actualidad, con frecuencia es de 4 bytes en sistemas de 32 bits y de 64 bits.

Aún así, usar sizeof(int) es la mejor manera de obtener el tamaño de un entero para el sistema específico en el que se ejecuta el progtwig.

EDITAR: Se arregló la afirmación errónea de que int es de 8 bytes en la mayoría de los sistemas de 64 bits. Por ejemplo, es 4 bytes en GCC de 64 bits.

Este es uno de los puntos en C que puede ser confuso al principio, pero el estándar C solo especifica un rango mínimo para los tipos enteros que se garantiza que es compatible. int se garantiza que puede contener -32767 a 32767, lo que requiere 16 bits. En ese caso, int , tiene 2 bytes. Sin embargo, las implementaciones son libres de ir más allá de ese mínimo, ya que verá que muchos comstackdores modernos hacen int 32 bits (lo que también significa 4 bytes bastante omnipresente).

La razón por la que su libro dice 2 bytes es probablemente porque es antigua. En un momento, esta era la norma. En general, siempre debe usar el operador sizeof si necesita saber cuántos bytes tiene en la plataforma que está utilizando.

Para solucionar esto, C99 agregó nuevos tipos en los que puede pedir explícitamente un entero de cierto tamaño, por ejemplo, int16_t o int32_t . Antes de eso, no había una forma universal de obtener un entero de un ancho específico (aunque la mayoría de las plataformas proporcionaban tipos similares por plataforma).

No hay una respuesta específica. Depende de la plataforma. Está definido por la implementación. Puede ser 2, 4 o algo más.

La idea detrás de int era que se suponía que coincidía con el tamaño natural de “palabra” en la plataforma dada: 16 bits en plataformas de 16 bits, 32 bits en plataformas de 32 bits, 64 bits en plataformas de 64 bits, se entiende la idea . Sin embargo, para fines de compatibilidad con versiones anteriores, algunos comstackdores prefieren mantener el int 32 bits incluso en plataformas de 64 bits.

Sin embargo, el tiempo de 2 bytes int se ha agotado (¿plataformas de 16 bits?) A menos que esté utilizando alguna plataforma integrada con tamaño de palabra de 16 bits. Tus libros de texto son probablemente muy antiguos.

La respuesta a esta pregunta depende de la plataforma que esté utilizando.
Pero independientemente de la plataforma, puede suponer de manera confiable los siguientes tipos:

  [8-bit] signed char: -127 to 127 [8-bit] unsigned char: 0 to 255 [16-bit]signed short: -32767 to 32767 [16-bit]unsigned short: 0 to 65535 [32-bit]signed long: -2147483647 to 2147483647 [32-bit]unsigned long: 0 to 4294967295 [64-bit]signed long long: -9223372036854775807 to 9223372036854775807 [64-bit]unsigned long long: 0 to 18446744073709551615 

¿Una variable entera en C ocupa 2 bytes o 4 bytes?

Eso depende de la plataforma que esté utilizando, así como de la configuración de su comstackdor. La única respuesta autorizada es usar el operador sizeof para ver qué tan grande es un entero en su situación específica.


¿Cuáles son los factores de los que depende?

El rango se puede considerar mejor que el tamaño . Ambos variarán en la práctica, aunque es mucho más a prueba de errores elegir tipos de variables por rango que tamaño, como veremos. También es importante tener en cuenta que el estándar nos anima a considerar elegir nuestros tipos de enteros basados ​​en el rango en lugar del tamaño , pero por ahora ignoremos la práctica estándar y dejemos que nuestra curiosidad explore sizeof , bytes y CHAR_BIT , y la representación entera … vamos a madriguera por el agujero del conejo y véalo por nosotros mismos …


sizeof , bytes y CHAR_BIT

La siguiente statement, tomada del estándar C (vinculada a arriba), describe esto en palabras que no creo que puedan mejorarse.

El operador sizeof produce el tamaño (en bytes) de su operando, que puede ser una expresión o el nombre entre paréntesis de un tipo. El tamaño se determina a partir del tipo de operando.

Asumir una comprensión clara nos llevará a una discusión sobre los bytes . Comúnmente se supone que un byte es de ocho bits, cuando CHAR_BIT te dice cuántos bits hay en un byte . Ese es solo otro de esos matices que no se tiene en cuenta al hablar de los enteros comunes de dos (o cuatro) bytes .

Vamos a terminar todo hasta ahora:

  • sizeof => tamaño en bytes, y
  • CHAR_BIT => número de bits en byte

Por lo tanto, dependiendo de su sistema, sizeof (unsigned int) podría ser cualquier valor mayor que cero (no solo 2 o 4), como si CHAR_BIT es 16, entonces un byte único (de dieciséis bits) tiene suficientes bits para representar el dieciséis bits enteros descritos por los estándares (citados a continuación). Esa no es necesariamente información útil, ¿verdad? Vamos a profundizar más …


Representación entera

El estándar C especifica la precisión / rango mínimo para todos los tipos de enteros estándar (y CHAR_BIT , también, fwiw) aquí . A partir de esto, podemos derivar un mínimo de cuántos bits se requieren para almacenar el valor , pero también podemos simplemente elegir nuestras variables basadas en rangos . No obstante, una gran parte del detalle requerido para esta respuesta reside aquí. Por ejemplo, lo siguiente que el estándar unsigned int requiere (al menos) dieciséis bits de almacenamiento:

 UINT_MAX 65535 // 2¹⁶ - 1 

Así podemos ver que unsigned int requiere ( al menos ) 16 bits , que es donde obtienes los dos bytes (asumiendo que CHAR_BIT es 8) … y más tarde cuando ese límite aumenta a 2³² - 1 , las personas indicaban 4 bytes en su lugar. Esto explica los fenómenos que has observado:

La mayoría de los libros de texto dicen que las variables enteras ocupan 2 bytes. Pero cuando ejecuto un progtwig que imprime las direcciones sucesivas de una matriz de enteros, muestra la diferencia de 4.

Está utilizando un antiguo libro de texto y comstackdor que le enseña C no portable; el autor que escribió su libro de texto podría no estar al tanto de CHAR_BIT . Debe actualizar su libro de texto (y su comstackdor) y esforzarse por recordar que TI es un campo en constante evolución que necesita para adelantarse a competir … Sin embargo, es suficiente; veamos qué otros secretos no portátiles esconden los bytes enteros

Los bits de valor son los que parecen estar contando los conceptos erróneos comunes. El ejemplo anterior usa un tipo entero unsigned signo que normalmente contiene solo bits de valor, por lo que es fácil pasar por alto al diablo en los detalles.

Bits de signos … En el ejemplo anterior UINT_MAX como el límite superior para unsigned int porque es un ejemplo trivial para extraer el valor 16 del comentario. Para los tipos con signo, para distinguir entre los valores positivos y negativos (ese es el signo), también debemos incluir el bit de signo.

 INT_MIN -32767 // -(2¹⁵ - 1) INT_MAX +32767 // 2¹⁵ - 1 

Relleno de bits … Si bien no es común encontrar computadoras que tengan bits de relleno en números enteros, el estándar C permite que eso suceda; algunas máquinas (es decir, esta ) implementan tipos enteros más grandes al combinar dos valores enteros más pequeños (con signo) juntos … y cuando combina enteros con signo, obtiene un bit de signo desperdiciado. Ese bit perdido se considera relleno en C. Otros ejemplos de bits de relleno podrían incluir bits de paridad y bits de captura .


Como puede ver, la norma parece alentar la consideración de rangos como INT_MIN .. INT_MAX y otros valores mínimos / máximos del estándar al elegir tipos enteros, y desalienta el uso de tamaños, ya que existen otros factores sutiles que probablemente se olviden, como CHAR_BIT y los bits de relleno que pueden afectar el valor de sizeof (int) (es decir, los conceptos erróneos comunes de los enteros de dos bytes y cuatro bytes ignoran estos detalles).

Calado estándar C99 N1256

http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf

El tamaño de int y todos los demás tipos de enteros están definidos en la implementación, C99 solo especifica:

  • garantías de tamaño mínimo
  • tamaños relativos entre los tipos

5.2.4.2.1 Tamaños de tipos enteros da los tamaños mínimos:

1 […] Sus valores definidos por la implementación serán iguales o mayores en magnitud (valor absoluto) a los mostrados […]

  • UCHAR_MAX 255 // 2 8 – 1
  • USHRT_MAX 65535 // 2 16 – 1
  • UINT_MAX 65535 // 2 16 – 1
  • ULONG_MAX 4294967295 // 2 32 – 1
  • ULLONG_MAX 18446744073709551615 // 2 64 – 1

6.2.5 Entonces, los tipos dicen:

8 Para dos tipos enteros con la misma firma y diferente rango de conversión entero (ver 6.3.1.1), el rango de valores del tipo con rango de conversión entero más pequeño es un subrango de los valores del otro tipo.

y 6.3.1.1 Booleanos, caracteres y enteros determinan los rangos de conversión relativos:

1 Cada tipo entero tiene un rango de conversión entero definido de la siguiente manera:

  • El rango de int largo largo será mayor que el rango de int largo, que será mayor que el rango de int, que será mayor que el rango de int corto, que será mayor que el rango de char firmado.
  • El rango de cualquier tipo de entero sin signo será igual al rango del tipo de entero con signo correspondiente, si lo hay.
  • Para todos los tipos enteros T1, T2 y T3, si T1 tiene un rango mayor que T2 y T2 tiene un rango mayor que T3, entonces T1 tiene un rango mayor que T3

Las únicas garantías son que char debe tener al menos 8 bits de ancho, short e int deben tener al menos 16 bits de ancho, y long deben tener al menos 32 bits de ancho, y ese sizeof (char) <= sizeof (short) <= sizeof (int) <= sizeof (long) (lo mismo es cierto para las versiones sin firmar de esos tipos).

int puede estar entre 16 y 64 bits de ancho dependiendo de la plataforma.

En su mayoría depende de la plataforma que está utilizando. Depende del comstackdor para comstackr. Actualmente, en la mayoría de los comstackdores int es de 4 bytes . Si desea verificar qué está usando su comstackdor, puede usar sizeof(int) .

 main() { printf("%d",sizeof(int)); printf("%d",sizeof(short)); printf("%d",sizeof(long)); } 

Lo único que promete el comstackdor c es que el tamaño del short debe ser igual o menor que int y el tamaño long debe ser igual o mayor que int.So si el tamaño de int es 4, entonces el tamaño del short puede ser 2 o 4 pero no más grande que eso. Lo mismo es cierto para largo e int. También dice que el tamaño de corto y largo no puede ser el mismo.

Esto depende de la implementación, pero generalmente en x86 y otras architectures populares como ARM int s toman 4 bytes. Siempre puede verificar en tiempo de comstackción usando sizeof(int) o cualquier otro tipo que desee verificar.

Si quiere asegurarse de usar un tipo de un tamaño específico, use los tipos en

 #include  int main(void) { printf("size of int: %d", (int)sizeof(int)); return 0; } 

Esto devuelve 4, pero es probable que dependa de la máquina.

Este progtwig puede explicar la diferencia básica entre las instrucciones de tiempo de comstackción y las instrucciones de tiempo de ejecución en la progtwigción C.

Aquí está el código:

 #include  main() { int a = 10,b; b= sizeof(a++); // b holds total number of bytes occupied in memory by a printf("\n %d %d \n", a,b); } 

El resultado esperado debe ser: a = 11, b = 4
( b contiene el número total de bytes ocupados en la memoria por a )

salida:

 gcc example.c -o example ./example 10 4 

Las instrucciones C se pueden clasificar en dos tipos:

  1. Instrucciones de tiempo de comstackción
  2. Instrucciones de tiempo de ejecución

Las instrucciones de tiempo de comstackción son aquellas instrucciones que se ejecutan durante el tiempo de comstackción.

Las instrucciones de tiempo de ejecución son aquellas instrucciones que se ejecutan durante el tiempo de ejecución

La mayoría de los desarrolladores no saben qué instrucciones entran en el tiempo de comstackción y qué instrucciones entran en el tiempo de ejecución.

Aquí sizeof es un operador de tiempo de comstackción, pero ++ es un operador de tiempo de ejecución. así que ++ es el operador que será ejecutado por la CPU y sizeof es la palabra clave que ejecutará el comstackdor en el momento de la comstackción.

cuando el comstackdor ha encontrado este tipo de instrucción b= sizeof(a++) , simplemente está reemplazando con el resultado de la expresión. el resultado de la expresión será el valor de retorno de sizeof . Cuando se genera el ejecutable, b mantendrá el valor de 4 . Entonces aquí el comstackdor elimina las instrucciones a++ . porque sizeof es una instrucción en tiempo de comstackción y se va a ejecutar. Ahora intentemos volver a escribir el código

 #include  main() { int a = 10,b; b = sizeof(a); a++; printf("\n %d %d \n", a,b); } 

 gcc example.c -o example ./example 11 4 

No podemos esperar que todas las instrucciones sean ejecutadas por la CPU.

Esta es una buena fuente para responder esta pregunta.

Pero esta pregunta es una especie de respuesta siempre verdadera “Sí. Ambos”.

Depende de tu architecture. Si va a trabajar en una máquina de 16 bits o menos, no puede ser de 4 bytes (= 32 bits). Si está trabajando en una máquina de 32 bits o superior, su longitud es de 32 bits.

Para averiguarlo, obtenga su progtwig listo para mostrar algo legible y use la función “tamaño de”. Eso devuelve el tamaño en bytes de su tipo de datos declarado. Pero sé cuidadoso al usar esto con arreglos.

Si declaras int t[12]; devolverá 12 * 4 bytes. Para obtener la longitud de este conjunto, simplemente use sizeof(t)/sizeof(t[0]) . Si vas a crear una función, que debería calcular el tamaño de una matriz de envío, recuerda que si

 typedef int array[12]; int function(array t){ int size_of_t = sizeof(t)/sizeof(t[0]); return size_of_t; } void main(){ array t = {1,1,1}; //remember: t= [1,1,1,0,...,0] int a = function(t); //remember: sending t is just a pointer and equal to int* t print(a); // output will be 1, since t will be interpreted as an int itselve. } 

Entonces esto ni siquiera devolverá algo diferente. Si define una matriz e intenta obtener la longitud posterior, use sizeof. Si envía una matriz a una función, recuerde que el valor de envío es solo un puntero en el primer elemento. Pero en el caso uno, usted siempre sabe, qué tamaño tiene su matriz. El segundo caso se puede resolver definiendo dos funciones y perdiendo algo de rendimiento. Definir función (matriz t) y definir función2 (matriz t, int tamaño_de_t). Llamar a “función (t)” mida la longitud con un poco de copia y envíe el resultado a la función 2, donde puede hacer lo que quiera en los tamaños de matriz variable.

¿El tamaño de C “int” es de 2 bytes o 4 bytes?

¿Una variable entera en C ocupa 2 bytes o 4 bytes?

C permite que los “bytes” sean algo más que 8 bits por “byte”.

CHAR_BIT número de bits para el objeto más pequeño que no es un campo de bits (byte) C11dr §5.2.4.2.1 1

Un valor de algo que 8 es cada vez más infrecuente. Para una portabilidad máxima, use CHAR_BIT lugar de 8. El tamaño de un int en bits en C es sizeof(int) * CHAR_BIT .

 #include  printf("(int) Bit size %zu\n", sizeof(int) * CHAR_BIT); 

¿Cuáles son los factores de los que depende?

El tamaño del bit int es comúnmente de 32 o 16 bits. C rangos mínimos especificados:

valor mínimo para un objeto de tipo int INT_MIN -32767
valor máximo para un objeto de tipo int INT_MAX
C11dr §5.2.4.2.1 1

El rango mínimo para int obliga a que el tamaño del bit sea al menos 16, incluso si el procesador era de “8 bits”. Se ve un tamaño de 64 bits en procesadores especializados. Otros valores como 18, 24, 36, etc. han ocurrido en plataformas históricas o son al menos teóricamente posibles. La encoding moderna rara vez se preocupa por los tamaños de bits int sin potencia-de-2.

El procesador y la architecture de la computadora controlan la selección del tamaño de bit int .

Sin embargo, incluso con procesadores de 64 bits, el tamaño int del comstackdor puede ser de 32 bits por razones de compatibilidad ya que las bases de código grandes dependen de que int sea ​​de 32 bits (o 32/16).

Sus 4 bytes, dependiendo del procesador. Puede usar long para 8 bytes, pero si el procesador tiene 32 palabras de bytes que sus 32 bytes.