La taille d'un int dépend-elle du compilateur et/ou du processeur?
La taille d'un entier dépendrait-elle du compilateur, du système d'exploitation et du processeur?
La réponse à cette question dépend de la distance qui nous sépare des considérations pratiques.
En fin de compte, en théorie, tout ce qui est en C et C++ dépend du compilateur et seulement du compilateur. Le matériel/le système d'exploitation n'a aucune importance. Le compilateur est libre d'implémenter une couche d'abstraction matérielle de any width et d'émuler absolument n'importe quoi. Rien n'empêche une implémentation C ou C++ d'implémenter le type int de toute taille et de toute représentation, tant qu'il est suffisamment grand pour répondre à la configuration minimale requise spécifiée dans le standard de langage. Des exemples pratiques d'un tel niveau d'abstraction sont facilement disponibles, par ex. langages de programmation basés sur la plate-forme "machine virtuelle", comme Java.
Cependant, C et C++ sont destinés à être très efficaces langages. Pour obtenir une efficacité maximale, une implémentation C ou C++ doit prendre en compte certaines considérations dérivées du matériel sous-jacent. Pour cette raison, il est judicieux de s’assurer que chaque type de base est basé sur une représentation directement (ou presque directement) prise en charge par le matériel. En ce sens, la taille des types de base dépend du matériel.
En d'autres termes, une implémentation spécifique en C ou C++ pour une plate-forme matériel/système d'exploitation 64 bits est tout à fait libre d'implémenter int en tant que type intégral signé à complément de 71 bits qui occupe 128 bits de mémoire, en utilisant les 57 autres bits comme remplissage bits qui sont toujours nécessaires pour stocker la date de naissance de la petite amie de l'auteur du compilateur. Cette implémentation aura même une certaine valeur pratique: elle peut être utilisée pour effectuer des tests à l'exécution de la portabilité des programmes C/C++. Mais c’est là que l’utilité pratique de cette mise en œuvre prendrait fin. Ne vous attendez pas à voir quelque chose comme ça dans un compilateur C/C++ "normal".
Oui, cela dépend à la fois des processeurs (plus particulièrement ISA, de l'architecture des jeux d'instructions, par exemple x86 et x86-64) et des compilateurs, y compris le modèle de programmation. Par exemple, dans les machines 16 bits, sizeof (int) était de 2 octets. Les ordinateurs 32 bits ont 4 octets pour int. On a considéré que int était la native taille d’un processeur, c’est-à-dire la taille du registre. Cependant, les ordinateurs 32 bits étaient si populaires et de nombreux logiciels ont été écrits pour le modèle de programmation 32 bits. Ainsi, il serait très déroutant que les ordinateurs 64 bits aient 8 octets pour int. Linux et Windows restent 4 octets pour int. Mais, ils diffèrent par la taille de long.
Veuillez regarder le modèle de programmation 64 bits comme LP64 pour la plupart * nix et LLP64 pour Windows:
- http://www.unix.org/version2/whatsnew/lp64_wp.html
- http://en.wikipedia.org/wiki/64-bit#64-bit_data_models
De telles différences sont en fait assez gênantes lorsque vous écrivez du code qui devrait fonctionner à la fois sous Windows et sous Linux. Donc, j'utilise toujours int32_t ou int64_t, plutôt que long, via stdint.h .
Oui, ce serait. Voulaient-ils dire "sur qui cela dépend-il: le compilateur ou le processeur"? Dans ce cas, la réponse est fondamentalement "les deux". Normalement, int ne sera pas plus gros qu'un registre de processeur (sauf s'il est inférieur à 16 bits), mais il pourrait être plus petit (par exemple, un compilateur 32 bits s'exécutant sur un processeur 64 bits). En règle générale, toutefois, vous aurez besoin d'un processeur 64 bits pour exécuter du code avec un int 64 bits.
Sur la base de quelques recherches récentes, j'ai étudié pour des interviews de micrologiciels:
L’impact le plus significatif de l’architecture des bits des processeurs, c’est-à-dire 8 bits, 16 bits, 32 bits et 64 bits, est la manière dont vous devez stocker le plus efficacement possible chaque octet d’informations afin de calculer au mieux les variables dans le nombre minimal de cycles.
La taille en bits de votre processeur vous indique la longueur de mot naturelle que le processeur est capable de gérer en un cycle. Une machine 32 bits nécessite 2 cycles pour gérer un double 64 bits s’il est correctement aligné en mémoire. La plupart des ordinateurs personnels étaient et sont toujours 32 bits, d’où la raison la plus probable de l’affinité typique du compilateur C pour les entiers 32 bits, avec des options pour les nombres plus grands et les entiers longs.
Il est clair que vous pouvez calculer des tailles de variable plus grandes. L’architecture binaire de la CPU détermine la manière dont elle va stocker les variables plus grandes et plus petites afin d’obtenir la meilleure efficacité de traitement possible, mais cela n’est nullement un facteur limitant dans la définition de la taille en octets. pour les caractères ou les caractères, cela fait partie des compilateurs et est dicté par les conventions ou les normes.
J'ai trouvé ce site très utile, http://www.geeksforgeeks.org/archives/9705 , pour expliquer comment la longueur naturelle du mot de la CPU influe sur la manière dont il choisira de stocker et de gérer des types de variables plus grands et plus petits, en particulier avec en ce qui concerne le bit d'emballage dans structs. Vous devez être très conscient de la façon dont vous avez choisi d'affecter les variables, car les variables plus grandes doivent être alignées en mémoire afin qu'elles prennent le moins de cycles possible lorsqu'elles sont divisées par la longueur en mots du processeur. Cela ajoutera beaucoup de mémoire tampon/espace potentiellement inutile à des éléments tels que structs si vous ordonnez mal l’affectation de vos variables.
La réponse simple et correcte est que cela dépend du compilateur. Cela ne signifie pas que l'architecture n'est pas pertinente, mais le compilateur en tient compte, pas votre application. Vous pourriez dire plus précisément que cela dépend de l'architecture (cible) du compilateur, par exemple si c'est 32 bits ou 64 bits.
Considérez que vous avez une application Windows qui crée un fichier dans lequel elle écrit une int ainsi que d'autres choses et le lit. Qu'est-ce qui se passe si vous exécutez cela sur les fenêtres 32 bits et 64 bits? Que se passe-t-il si vous copiez le fichier créé sur un système 32 bits et l'ouvrez dans un système 64 bits?
Vous pourriez penser que la taille de int sera différente dans chaque fichier, mais non, elles seront identiques, ce qui constitue le noeud de la question. Vous choisissez les paramètres dans le compilateur pour cibler une architecture 32 bits ou 64 bits et cela dicte tout.
la taille du type de données dépend essentiellement du type de compilateur et les compilateurs sont conçus sur la base de l’architecture des processeurs. Par conséquent, le type de données en externe peut être considéré comme dépendant du compilateur. dans le compilateur gcc bien qu'ils soient exécutés dans le même processeur
http://www.agner.org/optimize/calling_conventions.pdf
"3 représentation des données" contient un bon aperçu de ce que font les compilateurs avec les types intégraux.
La taille de l'int est égale à la longueur du mot qui dépend de l'ISA sous-jacent. Processeur est simplement l'implémentation matérielle de ISA et le compilateur est simplement l'implémentation logicielle de l'ISA. Tout tourne autour de l'ISA sous-jacent. Le plus populaire ISA est le IA-32 d’Intel de nos jours. sa longueur en mots est de 32 bits ou 4 octets. 4 octets pourraient être la taille maximale des compilateurs 'int' (tout simplement int, et non court ou long). basé sur IA-32, pourrait utiliser.
La taille des types de données dépend du processeur, car le compilateur veut rendre le processeur plus accessible pour l'octet suivant. Par exemple, si le processeur est 32 bits, le compilateur ne peut pas choisir une taille int de 2 octets [dont il est censé choisir 4 octets], car accéder à 2 autres octets de cet int (4 octets) nécessitera un cycle de traitement supplémentaire, ce qui représente une perte. Si le compilateur choisit int sur 4 octets, le processeur peut accéder à 4 octets complets en une seule fois, ce qui accélère votre application.
Merci