La taille de C “int” est-elle de 2 octets ou de 4 octets?

Je sais que c’est égal à sizeof(int) . La taille d’un int dépend vraiment du compilateur. À l’époque, lorsque les processeurs étaient 16 bits, un int était de 2 octets. De nos jours, il s’agit le plus souvent de 4 octets sur des systèmes 32 bits et 64 bits.

Cependant, l’utilisation de sizeof(int) est le meilleur moyen d’obtenir la taille d’un entier pour le système spécifique sur lequel le programme est exécuté.

EDIT: Correction de la fausse déclaration que int est de 8 octets sur la plupart des systèmes 64 bits. Par exemple, il s’agit de 4 octets sur GCC 64 bits.

C’est l’un des points de C qui peut être déroutant au début, mais le standard C spécifie uniquement une plage minimale pour les types entiers garantis. int est garanti de pouvoir contenir -32767 à 32767, ce qui nécessite 16 bits. Dans ce cas, int , est de 2 octets. Cependant, les implémentations sont libres d’aller au-delà de ce minimum, comme vous pourrez le voir avec de nombreux compilateurs modernes qui int 32 bits (ce qui signifie également 4 octets de manière assez omniprésente).

La raison pour laquelle votre livre dit 2 octets est probablement parce qu’il est ancien. A une époque, c’était la norme. En général, vous devez toujours utiliser l’opérateur sizeof si vous avez besoin de savoir combien d’octets il y a sur la plate-forme que vous utilisez.

Pour résoudre ce problème, C99 a ajouté de nouveaux types où vous pouvez demander explicitement un nombre entier, par exemple int16_t ou int32_t . Avant cela, il n’existait aucun moyen universel d’obtenir un entier d’une largeur spécifique (bien que la plupart des plates-formes fournissaient des types similaires sur une base par plate-forme).

Il n’y a pas de réponse spécifique. Cela dépend de la plateforme. Il est défini par la mise en œuvre. Cela peut être 2, 4 ou autre chose.

L’idée derrière int était qu’il était censé correspondre à la taille “mot” naturelle sur la plate-forme donnée: 16 bits sur les plates-formes 16 bits, 32 bits sur les plates-formes 32 bits, 64 bits sur les plates-formes 64 bits . Cependant, pour des raisons de rétrocompatibilité, certains compilateurs préfèrent restr sur les int 32 bits même sur les plates-formes 64 bits.

Le temps de 2 octets int disparu depuis longtemps (plates-formes 16 bits?) Sauf si vous utilisez une plate-forme intégrée avec une taille de mot de 16 bits. Vos manuels sont probablement très anciens.

La réponse à cette question dépend de la plate-forme que vous utilisez.
Mais quelle que soit la plate-forme, vous pouvez assumer de manière fiable les types suivants:

  [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 

Une variable entière dans C occupe-t-elle 2 octets ou 4 octets?

Cela dépend de la plate-forme que vous utilisez, ainsi que de la configuration de votre compilateur. La seule réponse autorisée est d’utiliser l’opérateur sizeof pour voir la taille d’un entier dans votre situation spécifique.

Quels sont les facteurs dont cela dépend?

La scope pourrait être mieux considérée, plutôt que la taille . Les deux varieront dans la pratique, mais il est beaucoup plus infaillible de choisir les types de variables par plage que par taille, comme nous le verrons. Il est également important de noter que la norme nous encourage à choisir nos types d’entiers en fonction de la plage plutôt que de la taille , mais ignorons pour l’instant la pratique standard et explorons la sizeof , les octets et CHAR_BIT , et la représentation entière … enfoncez le terrier du lapin et voyez par nous-mêmes …

sizeof , bytes et CHAR_BIT

La déclaration suivante, tirée de la norme C (liée à ci-dessus), décrit ceci dans des mots que je ne pense pas pouvoir améliorer.

L’opérateur sizeof donne la taille (en octets) de son opérande, qui peut être une expression ou le nom entre parenthèses d’un type. La taille est déterminée à partir du type de l’opérande.

En supposant une compréhension claire nous mènerons à une discussion sur les octets . On suppose généralement qu’un octet est de huit bits, alors qu’en réalité, CHAR_BIT vous indique le nombre de bits CHAR_BIT dans un octet . C’est juste une autre de ces nuances qui n’est pas prise en compte lorsque l’on parle des deux (ou quatre) octets entiers courants .

Emballons les choses jusqu’à présent:

• sizeof => taille en octets, et
• CHAR_BIT => nombre de bits dans l’octet

Ainsi, selon votre système, sizeof (unsigned int) peut avoir une valeur supérieure à zéro (pas seulement 2 ou 4), car si CHAR_BIT est 16, alors un seul octet (16 bits) contient suffisamment de bits pour représenter le entier de seize bits décrit par les normes (cité ci-dessous). Ce n’est pas nécessairement une information utile, n’est-ce pas? Plongeons plus profondément …

Représentation entière

La norme C spécifie ici la précision / plage minimale pour tous les types d’entiers standard (et CHAR_BIT aussi, fwiw). À partir de cela, nous pouvons dériver un minimum pour combien de bits sont nécessaires pour stocker la valeur , mais nous pouvons tout aussi bien choisir nos variables en fonction de plages . Néanmoins, une grande partie des détails requirejs pour cette réponse réside ici. Par exemple, le suivant que le standard unsigned int nécessite (au moins) seize bits de stockage:

 UINT_MAX 65535 // 2¹⁶ - 1 

Ainsi, nous pouvons voir que unsigned int requirejs ( au moins ) 16 bits , ce qui est là où vous obtenez les deux octets (en supposant que CHAR_BIT vaut 8) … et plus tard lorsque cette limite 2³² - 1 à 2³² - 1 , Ceci explique les phénomènes que vous avez observés:

La plupart des manuels disent que les variables entières occupent 2 octets. Mais quand je lance un programme imprimant les adresses successives d’un tableau d’entiers, il montre la différence de 4.

Vous utilisez un ancien manuel et compilateur qui vous apprend le C non portable; l’auteur qui a écrit votre manuel n’est peut-être même pas au courant de CHAR_BIT . Vous devriez mettre à jour votre manuel (et votre compilateur) et vous efforcer de vous rappeler que l’informatique est un domaine en constante évolution dont vous avez besoin pour restr compétitif … Assez sur ce point; Voyons ce que d’autres secrets non portables que les octets entiers sous-jacents stockent …

Les bits de valeur sont ce que les idées fausses communes semblent compter. L’exemple ci-dessus utilise un type d’entier unsigned qui ne contient généralement que des bits de valeur. Il est donc facile de rater le diable dans les détails.

Bits de signe … Dans l’exemple ci-dessus, j’ai cité UINT_MAX comme étant la limite supérieure de unsigned int car c’est un exemple sortingvial pour extraire la valeur 16 du commentaire. Pour les types signés, afin de distinguer les valeurs positives et négatives (c’est le signe), nous devons également inclure le bit de signe.

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

Bits de remplissage … Bien qu’il ne soit pas courant de rencontrer des ordinateurs dotés de bits de remplissage dans des nombres entiers, la norme C le permet; certaines machines (c’est-à – dire celle-ci ) implémentent des types d’entiers plus grands en combinant deux valeurs entières plus petites (signées) ensemble … et lorsque vous combinez des nombres entiers signés, vous obtenez un bit de signe perdu. Ce bit gaspillé est considéré comme un bourrage dans C. D’autres exemples de bits de remplissage peuvent inclure des bits de parité et des bits d’interruption .

Comme vous pouvez le constater, la norme semble encourager la prise en compte de plages telles que INT_MIN .. INT_MAX et d’ autres valeurs minimales / maximales dans le choix des types entiers, et décourager les tailles car il existe d’autres facteurs subtils comme CHAR_BIT et des bits de remplissage qui peuvent affecter la valeur de sizeof (int) (c.-à-d. que les idées fausses courantes sur les entiers de deux octets et de quatre octets négligent ces détails).

C99 N1256 projet standard

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

La taille de int et tous les autres types d’entiers sont définis par l’implémentation, C99 spécifie uniquement:

• taille minimum garantie
• tailles relatives entre les types

5.2.4.2.1 Tailles des types entiers donne les tailles minimales:

1 […] Leurs valeurs définies par la mise en œuvre doivent avoir une amplitude égale ou supérieure (valeur absolue) à celles indiquées […]

• 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 Types dit ensuite:

8 Pour deux types de nombres entiers ayant la même signature et le même rang de conversion d’entiers (voir 6.3.1.1), la plage de valeurs du type avec un rang de conversion entier plus petit est un sous-intervalle des valeurs de l’autre type.

et 6.3.1.1 Les booléens, les caractères et les entiers déterminent les rangs de conversion relatifs:

1 Chaque type d’entier a un classement de conversion d’entier défini comme suit:

• Le rang long long int doit être supérieur au rang de long int, qui doit être supérieur au rang de int, qui doit être supérieur au rang de short int, qui doit être supérieur au rang du caractère signé.
• Le rang de tout type entier non signé doit être égal au rang du type entier signé correspondant, le cas échéant.
• Pour tous les types entiers T1, T2 et T3, si T1 a un rang supérieur à T2 et que T2 a un rang supérieur à T3, alors T1 a un rang supérieur à T3.

Les seules garanties sont que char doit avoir au moins 8 bits de large, short et int doivent avoir au moins 16 bits de large et long doit avoir au moins 32 bits de large, et que sizeof (char) <= sizeof (short) <= sizeof (int) <= sizeof (long) (même chose pour les versions non signées de ces types).

int peut varier de 16 à 64 bits selon la plate-forme.

La plupart du temps, cela dépend de la plate-forme que vous utilisez. Cela dépend du compilateur et du compilateur. De nos jours, dans la plupart des compilateurs, int est de 4 octets . Si vous voulez vérifier ce que votre compilateur utilise, vous pouvez utiliser sizeof(int) .

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

La seule chose que le compilateur promet est que la taille de short doit être égale ou inférieure à int et que la taille de long doit être égale ou supérieure à int.Si la taille de int est 4, la taille de short peut être 2 ou 4 mais pas supérieure que cela.Same est vrai pour long et int. Il dit aussi que la taille du court et du long ne peut pas être la même.

Cela dépend de l’implémentation, mais généralement sur x86 et d’autres architectures populaires comme ARM int prennent 4 octets. Vous pouvez toujours vérifier au moment de la compilation en utilisant sizeof(int) ou tout autre type que vous souhaitez vérifier.

Si vous voulez vous assurer d’utiliser un type d’une taille spécifique, utilisez les types dans

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

Cela renvoie 4, mais cela dépend probablement de la machine.

Ce programme peut expliquer la différence de base entre les instructions de compilation et les instructions d’exécution en programmation C

Voici le code:

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

Le résultat attendu devrait être: a = 11, b = 4
( b contient le nombre total d’octets occupés en mémoire par a )

sortie:

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

Les instructions C peuvent être classées en deux types:

1. Comstackr les instructions de temps
2. Instructions d’exécution

Les instructions de compilation sont les instructions qui sont exécutées pendant la compilation.

Les instructions d’exécution sont les instructions qui sont exécutées pendant l’exécution

La plupart des développeurs ne savent pas quelles instructions entrent dans la compilation et quelles instructions entrent dans l’exécution.

Ici sizeof est un opérateur de compilation mais ++ est un opérateur d’exécution. so ++ est l’opérateur qui sera exécuté par le processeur et sizeof est le mot clé qui sera exécuté par le compilateur au moment de la compilation.

Lorsque le compilateur a rencontré ce type d’instruction b= sizeof(a++) , il remplace simplement par le résultat de l’expression. Le résultat de l’expression sera la valeur de retour de sizeof . Lorsque l’exécutable est généré, b aura la valeur 4 . Donc, ici, a++ instruction a++ est supprimée par le compilateur. car sizeof est une instruction de compilation et il va être exécuté. Maintenant, essayons de réécrire le code

 #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 

Nous ne pouvons pas nous attendre à ce que toutes les instructions soient exécutées par le CPU.

C’est une bonne source pour répondre à cette question.

Mais cette question est une sorte de réponse toujours vraie “Oui, les deux”.

Cela dépend de votre architecture. Si vous travaillez sur une machine 16 bits ou moins, il ne peut pas y avoir 4 octets (= 32 bits). Si vous travaillez sur une machine 32 bits ou supérieure, sa longueur est de 32 bits.

Pour vous faire une idée, préparez-vous au programme pour qu’il puisse afficher quelque chose de lisible et utiliser la fonction “sizeof”. Cela renvoie la taille en octets de votre type de données déclaré. Mais soyez prudent en utilisant ceci avec des tableaux.

Si vous déclarez int t[12]; il retournera 12 * 4 octets. Pour obtenir la longueur de ce tableau, utilisez simplement sizeof(t)/sizeof(t[0]) . Si vous allez créer une fonction, qui devrait calculer la taille d’un tableau d’envoi, rappelez-vous 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. } 

Donc, cela ne renverra même pas quelque chose de différent. Si vous définissez un tableau et tentez d’obtenir la longueur après, utilisez sizeof. Si vous envoyez un tableau à une fonction, rappelez-vous que la valeur d’envoi est juste un pointeur sur le premier élément. Mais si vous en connaissez un, vous savez toujours quelle est la taille de votre tableau. Le cas deux peut être compris en définissant deux fonctions et manquer certaines performances. Définir la fonction (tableau t) et définir function2 (tableau t, int size_of_t). Appelez “function (t)” mesurez la longueur par un travail de copie et envoyez le résultat à function2, où vous pouvez faire ce que vous voulez sur des tailles de tableau variables.

La taille de C “int” est-elle de 2 octets ou de 4 octets?

Une variable entière dans C occupe-t-elle 2 octets ou 4 octets?

C permet à “octets” d’être autre chose que 8 bits par “octet”.

CHAR_BIT nombre de bits pour le plus petit object qui n’est pas un champ binary (octet) C11dr §5.2.4.2.1 1

Une valeur de quelque chose de 8 est de plus en plus rare. Pour une portabilité maximale, utilisez CHAR_BIT plutôt que 8. La taille d’un int en bits dans C est sizeof(int) * CHAR_BIT .

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

Quels sont les facteurs dont cela dépend?

La taille du bit int est généralement de 32 ou 16 bits. C plages minimum spécifiées:

valeur minimale pour un object de type int INT_MIN -32767
valeur maximale pour un object de type int INT_MAX +32767
C11dr §5.2.4.2.1 1

La plage minimale pour int force la taille du bit à au moins 16 – même si le processeur était “8 bits”. Une taille comme 64 bits est vue dans les processeurs spécialisés. D’autres valeurs comme 18, 24, 36, etc. se sont produites sur des plates-formes historiques ou sont au moins théoriquement possibles. Le codage moderne s’inquiète rarement de la non-puissance de la taille des bits int .

Le processeur et l’architecture de l’ordinateur pilotent la sélection de taille de bit int .

Pourtant, même avec les processeurs 64 bits, la taille int du compilateur peut être de 32 bits pour des raisons de compatibilité, car de grandes bases de code dépendent de 32 bits (ou 32/16).

Ses 4 octets, en fonction du processeur.Il peut utiliser long pour 8 octets, mais si le processeur a 32 mots octet que ses 32 octets.