Pourquoi int est-il généralement 32 bits sur les compilateurs 64 bits?
Pourquoi int est-il généralement 32 bits sur les compilateurs 64 bits? Quand je commençais la programmation, on m'a appris que la taille était généralement la même que l'architecture sous-jacente. Et je suis d'accord que cela a également du sens, je trouve logique qu'un entier de largeur non spécifié soit aussi large que la plate-forme sous-jacente (sauf si nous parlons de machines 8 ou 16 bits, où une si petite plage pour int sera être à peine applicable).
Plus tard, j'ai appris que int était généralement de 32 bits sur la plupart des plates-formes 64 bits. Je me demande donc quelle en est la raison. Pour stocker des données, je préférerais une largeur explicitement spécifiée du type de données, ce qui laisse une utilisation générique pour int, qui n'offre aucun avantage en termes de performances, au moins sur mon système, j'ai les mêmes performances pour 32 et Entiers 64 bits. Cela laisse donc l'empreinte mémoire binaire, qui serait légèrement réduite, mais pas de beaucoup ...
Mauvais choix de la part des implémenteurs?
Sérieusement, selon la norme, "les entiers simples ont la taille naturelle suggérée par l'architecture de l'environnement d'exécution", ce qui signifie un 64 bits int sur une machine 64 bits. On pourrait facilement affirmer que tout le reste n'est pas conforme. Mais en pratique, les problèmes sont plus complexes: le passage de 32 bits int à 64 bits int permettrait pas à la plupart des programmes de gérer de grands ensembles de données ou autre chose (contrairement à le passage de 16 bits à 32); la plupart des programmes sont probablement limités par d'autres considérations. Et cela augmenterait la taille des ensembles de données et réduirait ainsi la localité et ralentirait le programme.
Enfin (et probablement le plus important), si int était de 64 bits, short devrait être soit 16 bits soit 32 bits, et vous n'auriez aucun moyen de spécifier l'autre (sauf avec les typedefs dans <stdint.h>, et l'intention est de ne les utiliser que dans des circonstances très exceptionnelles). Je soupçonne que c'était la principale motivation.
L'histoire, les compromis et les décisions sont expliqués par The Open Group à http://www.unix.org/whitepapers/64bit.html . Il couvre les différents modèles de données, leurs forces et leurs faiblesses et les modifications apportées aux spécifications Unix pour s'adapter à l'informatique 64 bits.
ints ont été 32 bits sur la plupart des architectures majeures pendant si longtemps que les changer en 64 bits causera probablement plus de problèmes qu'il n'en résout.
Parce que beaucoup de logiciels n'ont aucun avantage à avoir des entiers 64 bits.
Utiliser des int 64 bits pour calculer des choses qui peuvent être calculées dans un entier 32 bits (et à de nombreuses fins, des valeurs allant jusqu'à 4 milliards (ou +/- 2 milliards) sont suffisantes), et les agrandir ne sera d'aucune utilité.
L'utilisation d'un entier plus grand aura cependant un effet négatif sur le nombre d'entiers de "taille" de taille pouvant tenir dans le cache du processeur. Donc, les rendre plus grands rendra les calculs qui impliquent un grand nombre d'entiers (par exemple des tableaux) plus longs car.
Le int est la taille naturelle de la machine-Word n'est pas quelque chose stipulé par la norme C++. À l'époque où la plupart des machines étaient en 16 ou 32 bits, il était logique de le faire en 16 ou 32 bits, car il s'agit d'une taille très efficace pour ces machines. En ce qui concerne les machines 64 bits, cela n'aide plus. Donc rester avec 32 bits int est plus logique.
Edit: Fait intéressant, lorsque Microsoft est passé à 64 bits, ils n'ont même pas fait long 64 bits, car cela casserait trop de choses qui dépendaient de long étant une valeur 32 bits (ou plus important encore, ils avaient un tas de choses qui s'appuyaient sur long étant une valeur 32 bits dans leur API, où parfois le logiciel client utilise int et parfois long, et ils ne voulaient pas que ça casse).
La raison principale est la compatibilité descendante. De plus, il existe déjà un type entier 64 bits long et il en va de même pour les types flottants: float et double. Changer les tailles de ces types de base pour différentes architectures ne fera qu'introduire de la complexité. De plus, un entier 32 bits répond à de nombreux besoins en termes de plage.
J'ai écrit ceci à l'origine en réponse à cette question . Bien que j'en ai modifié certains, c'est en grande partie la même chose.
Pour commencer, il est possible d'avoir des entiers simples plus larges que 32 bits, comme le dit C++ draft :
Remarque: les entiers simples sont censés avoir la taille naturelle suggérée par l'architecture de l'environnement d'exécution ; les autres types d'entiers signés sont fournis pour répondre à des besoins particuliers. - note de fin
Emphase mine
Cela semblerait ostensiblement dire que sur mon architecture 64 bits (et celle de tous les autres) un int simple devrait avoir une taille 64 bits; c'est une taille suggérée par l'architecture, non? Cependant, je dois affirmer que la taille naturelle pour une architecture 64 bits, même est 32 bits. La citation dans les spécifications est principalement là pour les cas où des entiers simples 16 bits sont souhaités - ce qui est la taille minimale autorisée par les spécifications.
Le plus grand facteur est la convention, passer d'une architecture 32 bits avec un entier simple 32 bits et adapter cette source pour une architecture 64 bits est tout simplement plus facile si vous la gardez 32 bits, à la fois pour les concepteurs et leurs utilisateurs de deux manières différentes:
La première est que moins de différences entre les systèmes sont plus faciles pour tout le monde. Les écarts entre les systèmes n'ont été que des maux de tête pour la plupart des programmeurs: ils ne font que rendre plus difficile l'exécution du code sur les systèmes. Cela s'ajoutera même aux cas relativement rares où vous ne pouvez pas le faire sur des ordinateurs avec la même distribution à seulement 32 bits et 64 bits. Cependant, comme l'a souligné John Kugelman, les architectures sont passées de 16 bits à 32 bits en entier, ce qui pourrait être recommencé aujourd'hui, ce qui rejoint son point suivant:
Le composant le plus significatif est l'écart qu'il entraînerait dans les tailles entières ou un nouveau type requis. Parce que sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long) est dans la spécification réelle, un espace est forcé si le plain int est déplacé sur 64 bits. Il commence par déplacer long. Si un entier simple est ajusté à 64 bits, la contrainte que sizeof(int) <= sizeof(long) forcerait long à être au moins 64 bits et à partir de là il y a un écart intrinsèque dans les tailles. Étant donné que long ou un entier simple sont généralement utilisés comme un entier 32 bits et qu'aucun d'entre eux ne le pourrait maintenant, nous n'avons qu'un seul type de données en plus, short. Parce que short a un minimum de 16 bits si vous jetez simplement cette taille, elle pourrait devenir 32 bits et combler théoriquement cet écart, cependant short est destiné à être optimisé pour l'espace donc devrait être conservé comme ça et il y a existe cas d'utilisation pour les petits entiers 16 bits également. Peu importe la façon dont vous organisez les tailles, il y a une perte de largeur et utilisez donc un cas pour un int totalement indisponible. Une plus grande largeur ne signifie pas nécessairement que c'est mieux.
Cela impliquerait maintenant une exigence de modification des spécifications, mais même si un concepteur devient voyou, il est fort probable qu'il soit endommagé ou obsolète à la suite du changement. Les concepteurs de systèmes durables doivent travailler avec une base entière de code entrelacé, à la fois le leur dans le système, les dépendances et le code de l'utilisateur qu'ils voudront exécuter et une énorme quantité de travail pour le faire sans tenir compte des répercussions est tout simplement imprudent .
En remarque, si votre application est incompatible avec un entier> 32 bits, vous pouvez utiliser static_assert(sizeof(int) * CHAR_BIT <= 32, "Int wider than 32 bits!");. Cependant, qui sait peut-être que les spécifications le seront changer et que les entiers simples 64 bits seront implémentés, donc si vous voulez être à l'épreuve du temps, ne faites pas l'assertion statique.
Puisque personne ne l'a encore signalé.
int est garanti entre - 32767 à 32767 (2^16) C'est requis par la norme. Si vous souhaitez prendre en charge les nombres 64 bits sur toutes les plates-formes, je vous suggère d'utiliser le bon type long long qui prend en charge (- 9223372036854775807 à 9223372036854775807).
int peut être n'importe quoi tant qu'il fournit la plage minimale requise par la norme.
La norme C + + ne dit pas combien de mémoire doit être utilisée pour le type int, vous indique combien de mémoire doit être utilisée au moins pour le type int. Dans de nombreux environnements de programmation sur des variables de pointeur 32 bits, "int" et "long" sont tous de 32 bits.