Pourquoi court, int et long ont-ils été inventés en C?

Je vais avoir du mal à comprendre, quels étaient les besoins exacts de la création de la short, intet les longtypes de données en C?

La raison pour laquelle je demande, c'est qu'il ne semble pas que leurs tailles soient délimitées - elles pourraient être de n'importe quelle taille, tant qu'elles shortsont plus petites qu'un an int, par exemple.

Dans quelles situations, alors, devez-vous utiliser un unsigned intou unsigned long, par exemple, au lieu d'un size_t, alors que cela n'offre aucun espoir de compatibilité binaire?

(Si vous ne connaissez pas la taille, comment sauriez-vous quand choisir laquelle?)

Il serait défini par l'architecture que vous utilisiez. Sur une puce Zilog z80 (puce intégrée commune), ils seraient d'une taille alors qu'ils pourraient être d'une taille entièrement différente sur un chipset x86. Cependant, les tailles elles-mêmes sont des rapports fixes les uns par rapport aux autres. Essentiellement courts et longs ne sont pas des types mais remplissent les conditions requises pour le type int. Les pouces courts seront d'un ordre de grandeur plus petits que les int (réguliers) et les pouces longs seront d'un ordre de grandeur plus élevés. Supposons donc que votre Int soit limité à 4 octets, le qualificatif court le limite à 4 octets, bien que 2 octets soient également très courants et le qualificatif long le renforce potentiellement à 8 octets, bien qu'il puisse être inférieur à 4 octets. Gardez à l'esprit que cela est également soumis à la longueur des mots, donc sur un système 32 bits, vous obtiendrez un maximum de 4 octets par entier, ce qui rend long identique à un entier normal. Ainsi, Court ≤ Int ≤ Long.

Cependant, si vous l'allongez à nouveau, vous pouvez insérer l'int dans la cellule suivante, vous donnant 8 octets entiers de stockage. Il s'agit de la taille des mots pour les machines 64 bits, de sorte qu'ils n'ont pas à se soucier de telles choses et utilisent simplement une cellule pour les entiers longs, ce qui leur permet d'être un autre ordre au-dessus des entiers standard tandis que les longs entiers deviennent vraiment mignons.

En ce qui concerne le choix, cela se résume à quelque chose que les programmeurs Java, par exemple, n'ont pas à se soucier. "Quelle est votre architecture?" Comme tout dépend de la taille des mots de la mémoire de la machine en question, vous devez le comprendre à l'avance avant de décider lequel utiliser. Vous choisissez ensuite la plus petite taille raisonnable pour économiser autant de mémoire que possible car cette mémoire sera allouée, que vous utilisiez tous les bits ou non. Ainsi, vous économisez où vous le pouvez et choisissez des shorts quand vous le pouvez et des poils quand vous ne le pouvez pas et si vous avez besoin de quelque chose de plus grand que ce que vous donnez régulièrement; vous allongez au besoin jusqu'à ce que vous atteigniez le plafond de mots. Ensuite, vous devez fournir des routines à grand nombre ou les obtenir dans une bibliothèque.

C peut bien être un "assemblage portable" mais vous devez toujours connaître votre matériel.

Bien qu'aujourd'hui, un "octet" signifie "8 bits", cela n'a pas toujours été vrai. Les machines ont utilisé des blocs adressables de 4 bits, 8 bits, 12 bits, 16 bits, 32 bits et 36 bits (et probablement d'autres tailles également). L'une des intentions de conception de C était d'être utilisable sur des machines avec différentes tailles et configurations de mémoire.

Je pense que l'intention de conception était à l'origine que chaque type soit autre que intla plus petite chose qui puisse gérer des nombres de différentes tailles, et que ce intsoit la taille "polyvalente" la plus pratique qui puisse gérer +/- 32767. Je ne pense pas qu'il y ait eu un désir ou une intention de créer un langage qui serait encore utilisé lorsque les ordinateurs sont devenus si puissants que les opérations sur les nombres 64 bits coûtent le même prix que les opérations sur les plus petits.

Le plus gros problème avec la sémantique de type entier de C est que dans certains contextes, ils représentent des nombres cardinaux ou des entiers mathématiques, tandis que dans d'autres contextes, ils sont utilisés pour représenter les membres d'un anneau algébrique abstrait enveloppant d'entiers mod congruent mod 2 ^ n [donc par exemple, soustraire la valeur maximale représentable de 0 est définie pour donner 1], mais les comportements sont spécifiés davantage sur la base de ce que les compilateurs semblaient faire les jours où la taille des mots de l'ordinateur était d'environ 16 bits (et une taille de mot de 36 bits aurait été énorme ), plutôt que sur la base de ce qui aurait du sens sur une machine 64 bits. Par conséquent, le résultat de la soustraction d'une valeur non signée 32 bits d'une valeur 32 bits non signée plus petite peut être soit une grande valeur non signée 32 bits, soit un nombre négatif de 64 bits.

/programming/589575/size-of-int-long-etc

Ainsi, dans les architectures les plus couramment utilisées, char vaut 1 octet, short et int au moins 2 octets, et long au moins 4 octets.

Et il est prévu que «int» soit la représentation la plus naturelle / normale / efficace pour le processeur actuel.

La règle générale est donc d'utiliser 'int' à moins que vos valeurs dépassent +/- 32K, ce qui vous oblige (sur les CPU plus anciens) à utiliser 'long'. ... ou à moins que vous ne fassiez de grands tableaux de petites valeurs (<32K), et que la mémoire soit un problème - vous utiliseriez donc 'short' pour économiser de la mémoire (ou peut-être 'char' ou 'byte').

C a été conçu pour gérer activement la mémoire à différents niveaux. Il y a des cas où la différence entre court, int et long, et entre flottant et double, importait en raison des contraintes de mémoire, de l'architecture, etc. cas où les données sont massives), et la transition des architectures principalement 32 bits à 64 bits en fait à nouveau un problème. (Dans dix ou vingt ans, lorsque nous passerons à des architectures 128 bits et que C / C ++ est toujours populaire, ce sera à nouveau un problème). Vous avez raison, bien que la compatibilité binaire en souffre, c'est pourquoi vous ne voulez pas utiliser ces tailles de types variables là où cela compte.

Vous avez demandé comment vous sauriez lequel utiliser si vous ne connaissez pas la taille, mais vous connaissez la taille sur une combinaison architecture / compilateur donnée, et si vous avez besoin d'optimiser la mémoire à ce niveau, vous feriez mieux de la connaître. Vous ne pouvez pas l'optimiser simplement sur plusieurs plates-formes parce que vous ne pouvez pas connaître leurs tailles, vous ne voudriez donc pas utiliser ces fonctionnalités à cette fin. Mais beaucoup de choses écrites en C sont spécifiques à la plate-forme, ce qui, malgré la mode de «multiplateforme», permet des optimisations avantageuses.