Si les machines 32 bits ne peuvent gérer que des nombres allant jusqu'à 2 ^ 32, pourquoi puis-je écrire 1000000000000 (billions de dollars) sans que ma machine ne tombe en panne?

Question

Les ordinateurs 32 bits ne peuvent stocker que des entiers signés jusqu'à 2³¹ - 1.
C’est la raison pour laquelle nous n’avons plus d’adresses IPv4 et sommes entrés dans l’ère des 64 bits.

Cependant, le nombre 2³¹ - 1 (2 147 483 647) n’est pas aussi grand que le chiffre 1 000 milliards (1 000 000 000 000) que je semble être capable d’afficher parfaitement sans que ma machine ne tombe en panne.

Quelqu'un peut-il expliquer pourquoi c'est?

Scott Chamberlain · Accepted Answer

Je réponds à votre question en vous en demandant une autre:

Comment comptez-vous sur vos doigts à 6?

Vous comptez probablement jusqu'au plus grand nombre possible avec une main, puis vous passez à votre seconde main lorsque vous êtes à court de doigts. Les ordinateurs font la même chose. S'ils ont besoin de représenter une valeur supérieure à celle d'un registre unique, ils utiliseront plusieurs blocs 32 bits pour travailler avec les données.

Bigbio2002 · Answer

Vous avez raison de dire qu'un entier 32 bits ne peut contenir une valeur supérieure à 2 ^ 32-1. Cependant, la valeur de cet entier 32 bits et son affichage à l'écran sont deux choses complètement différentes. La chaîne imprimée "1000000000000" n'est pas représentée par un entier de 32 bits en mémoire.

Pour afficher littéralement le nombre "1000000000000", il faut 13 octets de mémoire. Chaque octet peut contenir une valeur maximale de 255. Aucun d’entre eux ne peut contenir la valeur numérique entière, mais il est interprété individuellement comme étant ASCII caractères (par exemple, le caractère '0' est représenté par une valeur décimale. 48 , valeur binaire 00110000), ils peuvent être enchaînés dans un format qui a du sens pour vous, un humain.

Un concept associé en programmation est typecasting , qui explique comment un ordinateur interprétera un flux particulier de 0s et de 1s. Comme dans l'exemple ci-dessus, il peut être interprété comme une valeur numérique, un caractère ou même autre chose. Bien qu'un entier 32 bits puisse ne pas contenir une valeur de 1000000000000, un nombre à virgule flottante 32 bits pourra utiliser une interprétation totalement différente.

En ce qui concerne la manière dont les ordinateurs peuvent travailler avec et traiter de grands nombres en interne, il existe des entiers 64 bits (pouvant contenir des valeurs allant jusqu'à 16 milliards de milliards), des valeurs à virgule flottante, ainsi que des bibliothèques spécialisées pouvant fonctionner avec des valeurs Nombres.

gronostaj · Answer

D'abord et avant tout, les ordinateurs 32 bits peuvent stocker des nombres allant jusqu'à 2³²-1 dans un seul ordinateur Word . Mot machine est la quantité de données que la CPU peut traiter de manière naturelle (c.-à-d. Que les opérations sur des données de cette taille sont implémentées dans le matériel et sont généralement les plus rapides à exécuter). Les processeurs 32 bits utilisent des mots de 32 bits. Ils peuvent donc stocker des nombres compris entre 0 et 2³²-1 dans un mot .

Deuxièmement, 1 billion de dollars et 1000000000000 sont deux choses différentes.

1 billion de dollars est un concept abstrait de nombre
1000000000000 est un texte

En appuyant 1 une fois et ensuite 12 fois vous tapez du texte. 1 Entrées 1, Entrées 0. Voir? Vous tapez des caractères. Les caractères ne sont pas des nombres. Les machines à écrire n’avaient ni processeur, ni mémoire, et elles géraient plutôt bien de tels "nombres", car il ne s’agissait que de texte.

La preuve que 1000000000000 n'est pas un nombre, mais du texte: il peut signifier 1 billion de dollars (en décimal) ), 4096 (en binaire) ou 281474976710656 (en hexadécimal). Il a encore plus de significations dans différents systèmes. Signification de 1000000000000 est un nombre et le stocker est une histoire différente (nous y reviendrons dans un instant).

Pour stocker le texte (en programmation, cela s'appelle chaîne ) 1000000000000 vous avez besoin de 14 octets (un pour chaque caractère plus un octet NULL final). cela signifie fondamentalement "la chaîne se termine ici"). C'est 4 mots machine. 3 et demi suffiraient, mais comme je l'ai dit, les opérations sur les mots machine sont les plus rapides. Supposons que ASCII est utilisé pour le stockage de texte. En mémoire, cela ressemblera à ceci: (convertir les codes ASCII correspondant à 0 et 1 en binaires, chaque mot sur une ligne distincte)

00110001 00110000 00110000 00110000 00110000 00110000 00110000 00110000 00110000 00110000 00110000 00110000 00110000 00000000 00000000 00000000

Quatre caractères tiennent dans un mot, le reste est déplacé au suivant. Le reste est déplacé vers le prochain mot jusqu'à ce que tout (y compris le premier octet NULL) rentre.

Revenons maintenant à la mémorisation des numéros. Cela fonctionne comme avec un texte en débordement, mais ils sont ajustés de droite à gauche. Cela peut sembler compliqué, alors voici un exemple. Par souci de simplicité, supposons que:

notre ordinateur imaginaire utilise décimal au lieu de binaire
un octet peut contenir des nombres 0..9
un mot est constitué de deux octets

Voici une mémoire vide de 2 mots:

0 0 0 0

Stockons le numéro 4:

0 4 0 0

Ajoutons maintenant 9:

1 3 0 0

Notez que les deux opérandes peuvent tenir dans un octet, mais pas le résultat. Mais nous en avons un autre prêt à être utilisé. Maintenant, stockons 99:

9 9 0 0

De nouveau, nous avons utilisé le deuxième octet pour stocker le numéro. Ajoutons 1:

0 0 0 0

Oups ... C'est ce qu'on appelle un dépassement d'entier et est à l'origine de nombreux problèmes graves, parfois très coûteux .

Mais si nous nous attendons à ce que le débordement se produise, nous pouvons le faire:

0 0 9 9

Et maintenant, ajoutez 1:

0 1 0 0

Cela devient plus clair si vous supprimez les espaces et les nouvelles lignes séparant les octets:

0099 | +1 0100

Nous avons prédit qu'un débordement pourrait se produire et nous aurions peut-être besoin de mémoire supplémentaire. Gérer les chiffres de cette façon n'est pas aussi rapide qu'avec des chiffres qui ne peuvent contenir qu'un seul mot et doit être implémenté dans un logiciel. L'ajout de la prise en charge de deux nombres de mots 32 bits à un processeur 32 bits en fait un processeur 64 bits (il peut désormais fonctionner en mode natif sur des nombres 64 bits, n'est-ce pas?).

Tout ce que j'ai décrit ci-dessus s'applique également à la mémoire binaire avec des octets de 8 bits et des mots de 4 octets, cela fonctionne à peu près de la même manière:

00000000 00000000 00000000 00000000 11111111 11111111 11111111 11111111 | +1 00000000 00000000 00000000 00000001 00000000 00000000 00000000 00000000

La conversion de tels nombres en système décimal est cependant délicate. (mais cela fonctionne assez bien avec hexadécimal )

o.v. · Answer

Vous êtes également capable d'écrire "CETTE DÉCLARATION IS FAUX" sans que votre ordinateur ne tombe en panne :) @ La réponse de Scott est parfaite pour certains cadres de calcul, mais votre question "d'écriture" a Un grand nombre implique qu'il ne s'agit que de texte brut, du moins jusqu'à ce qu'il soit interprété.

Modifier: maintenant avec ~~moins de sarcasme~~ des informations plus utiles sur les différentes manières dont un numéro peut être stocké en mémoire. Je les décrirai avec abstraction plus élevée _ c'est-à-dire qu'un programmeur moderne pourrait écrire du code avant qu'il ne soit traduit en code machine pour son exécution.

Les données sur un ordinateur doivent être limitées à un certain type, et une définition de ce type d'ordinateur décrit les opérations qui peuvent être effectuées sur ces données et comment (comparer des chiffres, concaténer du texte ou XOR un booléen). Vous ne pouvez pas simplement ajouter du texte à un nombre, tout comme vous ne pouvez pas multiplier un nombre par du texte afin que certaines de ces valeurs puissent être converties entre types.

Commençons par entiers non signés. Dans ces types de valeur, tous les bits sont utilisés pour stocker des informations sur les chiffres; yours est un exemple de entier non signé de 32 bits} où toute valeur comprise entre 0 et 2^32-1 peut être stockée. Et oui, selon le langage ou l'architecture de la plate-forme utilisée, vous pouvez avoir des entiers 16 bits ou 256 bits.

Et si vous voulez être négatif? Intuitivement, entiers signés est le nom du jeu. Convention consiste à attribuer toutes les valeurs de -2^(n-1) à 2^(n-1)-1. De cette manière, nous évitons la confusion liée au fait de devoir traiter deux manières d'écrire +0 et -0. Ainsi, un entier signé 32 bits contiendrait une valeur de -2147483648 à 2147483647. Neat, n'est ce pas?

Ok, nous avons couvert les entiers qui sont des nombres sans composante décimale. Leur expression est plus délicate: la partie non entière ne peut raisonnablement être comprise qu'entre 0 et 1, de sorte que chaque bit supplémentaire utilisé pour la décrire augmente sa précision: 1/2, 1/4, 1/8 ... Le problème est , vous ne pouvez pas exprimer avec précision un simple 0.1 décimal en tant que somme de fractions dont le dénominateur ne peut avoir qu'une puissance de deux! Ne serait-il pas beaucoup plus facile de stocker le nombre sous forme d’entier, mais d’accepter de placer le point décimal à la place? Ceci s'appelle point fixe} nombres, où nous stockons 1234100 mais convenons d'une convention pour le lire en tant que 1234.100 à la place.

floating point est un type relativement commun utilisé pour les calculs. La façon dont cela fonctionne est vraiment soignée, il utilise un bit pour stocker la valeur du signe, puis certains pour stocker exposant et significande. Il existe des normes qui définissent de telles allocations, mais pour un float 32 bits , le nombre maximum que vous pourriez stocker est écrasant.

(2 - 2^-23) * 2^(2^7 - 1) ≈ 3.4 * 10^38

Cela se fait toutefois au détriment de la précision. JavaScript disponible dans les navigateurs utilise des flottants 64 bits, et il ne parvient toujours pas à faire les choses correctement. Copiez simplement ceci dans la barre d'adresse et appuyez sur Entrée. Alerte spoiler: le résultat est pas va être 0.3.

javascript:alert(0.1+0.2);

Il existe plusieurs types alternatifs, tels que BigInteger , de Microsoft .NET 4.5, qui théoriquement n’a pas de limites supérieure ou inférieure et doit être calculé par «lots»; mais les technologies les plus fascinantes sont peut-être celles qui comprennent mathématiques, comme le moteur Wolfram Mathematica, qui peut fonctionner avec des valeurs abstraites telles que infinity .

matt_black · Answer

La clé est de comprendre comment les ordinateurs encodent nombres.

Bien sûr, si un ordinateur insiste pour stocker des nombres en utilisant une simple représentation binaire du nombre en utilisant un seul mot (4 octets sur un système 32 bits), un ordinateur 32 bits ne peut stocker que des nombres allant jusqu'à 2 ^ 32. Mais il existe de nombreuses autres manières d’encoder des nombres en fonction de ce que vous voulez réaliser avec eux.

Un exemple est la façon dont les ordinateurs stockent les nombres en virgule flottante. Les ordinateurs peuvent utiliser de nombreuses façons différentes pour les encoder. La norme IEEE 754 définit des règles pour coder des nombres supérieurs à 2 ^ 32. En gros, les ordinateurs peuvent y parvenir en divisant les 32 bits en différentes parties représentant quelques chiffres du nombre et d’autres bits représentant le size du nombre (c’est-à-dire l’exposant, 10 ^ x). Cela permet un nombre plage de nombres beaucoup plus grand en termes de taille, mais compromet la précision (ce qui est OK pour de nombreuses raisons). Bien entendu, l'ordinateur peut également utiliser plus d'un mot pour cet encodage, augmentant ainsi la précision de la magnitude des nombres encodés disponibles. La version 32 simple décimale de la norme IEEE autorise des nombres avec environ 7 chiffres décimaux de précision et des nombres allant jusqu'à environ 10 ^ 96 de magnitude.

Mais il existe de nombreuses autres options si vous avez besoin de la précision supplémentaire. Évidemment, vous pouvez utiliser plus de mots dans votre encodage sans limite (avec toutefois une pénalité de performance pour convertir en format encodé). Si vous souhaitez explorer une solution, il existe un excellent complément Open Source pour Excel qui utilise un schéma de codage permettant des centaines de chiffres de précision dans le calcul. Le complément s'appelle Xnumbers et est disponible ici . Le code est en Visual Basic, ce qui n'est pas le plus rapide possible mais présente l'avantage d'être facile à comprendre et à modifier. C'est un excellent moyen d'apprendre comment les ordinateurs parviennent à coder des nombres plus longs. Et vous pouvez jouer avec les résultats dans Excel sans avoir à installer aucun outil de programmation.

user1306322 · Answer

Tout est dans votre question.

Vous pouvez écrire n’importe quel nombre sur papier. Essayez d’écrire un billion de points sur une feuille de papier blanc. C'est lent et inefficace. C'est pourquoi nous avons un système à 10 chiffres pour représenter ces gros chiffres. Nous avons même des noms pour les grands nombres tels que "million", "billion" et plus, de sorte que vous ne dites pas one one one one one one one one one one one... à haute voix.

Les processeurs 32 bits sont conçus pour fonctionner plus rapidement et efficacement avec des blocs de mémoire de 32 chiffres exactement. Mais nous, les gens, utilisons généralement un système numérique à 10 chiffres, et les ordinateurs, étant électroniques, utilisons un système à 2 chiffres ( binaire ). Les nombres 32 et 64 sont des puissances de 2. Il en est de même pour un million et un billion. Il est plus facile pour nous de fonctionner avec ces chiffres que des multitudes de 65 536, par exemple.

Nous divisons les gros nombres en chiffres lorsque nous les écrivons sur papier. Les ordinateurs décomposent les nombres en un plus grand nombre de chiffres. Nous pouvons écrire n'importe quel nombre, et les ordinateurs aussi, si nous les concevons.

Engineer · Answer

32 bits et 64 bits se réfèrent aux adresses de mémoire. La mémoire de votre ordinateur est semblable aux boîtes postales, chacune ayant une adresse différente. La CPU (Central Processing Unit) utilise ces adresses pour adresser des emplacements de mémoire sur votre RAM (mémoire à accès aléatoire). Lorsque le processeur ne pouvait gérer que les adresses 16 bits, vous ne pouviez utiliser que 32 Mo de RAM (qui semblait énorme à l'époque). Avec 32 bits, il est passé à 4 + Go (ce qui semblait énorme à l'époque). Maintenant que nous avons des adresses 64 bits, la RAM va en téraoctets (ce qui semble énorme).
Cependant, le programme peut allouer plusieurs blocs de mémoire pour le stockage de chiffres et de texte, qui relèvent du programme et ne sont pas liés à la taille de chaque adresse. Donc, un programme peut dire au processeur, je vais utiliser 10 blocs d’adresses de stockage puis stocker un très grand nombre, ou une chaîne de 10 lettres ou autre.
Note latérale: Les adresses de la mémoire sont pointées par des "pointeurs". Les valeurs 32 et 64 bits désignent donc la taille du pointeur utilisé pour accéder à la mémoire.

noob · Answer

Parce que l'affichage du nombre est fait en utilisant des caractères individuels, pas des entiers. Chaque chiffre du numéro est représenté par un littéral de caractère distinct, dont la valeur entière est définie par le codage utilisé. Par exemple, 'a' est représenté par la valeur ascii 97, tandis que '1' est représenté par 49. Vérifiez la table ascii ici .
Pour afficher "a" et "1" sont identiques. Ce sont des littéraux de caractères, pas des entiers. Chaque littéral de caractère peut avoir une valeur maximale de 255 sur une plate-forme 32 bits, stockant cette valeur en taille de 8 bits ou en octets (dépend de la plate-forme, mais 8 bits est la taille de caractère la plus courante), afin de pouvoir être regroupés et affiché. Le nombre de caractères distincts qu’ils peuvent afficher dépend de la RAM que vous avez. Si vous n'avez qu'un octet de RAM, vous ne pouvez afficher qu'un seul caractère; si vous avez 1 Go de RAM, vous pouvez afficher 1024 * 1024 * 1024 caractères (trop paresseux pour faire le calcul).

Cette limitation s’applique toutefois aux calculs, mais je suppose que la norme IPV4 vous intéresse. Bien que cela ne soit pas entièrement lié au bit-size de l'ordinateur, cela a en quelque sorte affecté les normes. Lors de la création de la norme IPV4, ils stockaient les valeurs ip dans des entiers 32 bits. Maintenant, une fois que vous avez donné la taille, elle est devenue la norme. Tout ce que nous savions sur Internet en dépendait, puis nous n’avions plus d’adresses IP à attribuer. Donc, si la norme IP a été révisée en 64 bits, tout va cesser de fonctionner, y compris votre routeur (je suppose que cela est correct) et d’autres périphériques réseau. Il faut donc créer un nouveau standard, qui vient d’échanger l’entier sur 32 bits avec celui à 128 bits. Et ajusté reste de la norme. Le fabricant de matériel informatique doit simplement déclarer qu'il prend en charge cette nouvelle norme et que cela deviendra viral. Bien que ce ne soit pas si simple, mais je suppose que vous avez compris le point.

Disclaimer: La plupart des points mentionnés ici sont fidèles à mon hypothèse. J'ai peut-être manqué des points importants pour simplifier les choses. Je ne suis pas doué pour les chiffres, alors j'ai dû manquer quelques chiffres, mais ce que je veux dire ici est de répondre à la réponse du PO indiquant pourquoi il ne plante pas le PC.

sanaris · Answer

Dans les processeurs, il y a des "mots". Il y a des mots différents. Quand les gens disent "processeur 32 bits", ils veulent dire surtout "largeur du bus mémoire". Ce mot est constitué de différents "champs", qui font référence à des sous-systèmes d'ordinateur correspondant à la transmission (24 bits) et au contrôle (autres bits). Je peux me tromper sur les chiffres exacts, assurez-vous de cela à l'aide de manuels.

Un aspect complètement différent est le calcul. SSE et les jeux d'instructions MMX peuvent stocker des entiers longs. La longueur maximale sans perte de productivité dépend de la version actuelle de SSE, mais elle est toujours multiple de 64 bits.

Les processeurs Opteron actuels peuvent gérer des nombres d'une largeur de 256 bits (je ne suis pas sûr du nombre entier, mais float l'est à coup sûr).

Résumé : (1) la largeur du bus n'est pas connectée directement à la largeur de calcul, (2) même des mots différents (mot de mémoire, mot de registre, mot de bus, etc.) ne sont pas connectés les uns aux autres, sinon ils ont un diviseur commun 8 ou 16 ou 24. De nombreux processeurs ont même utilisé Word 6 bits (mais son historique).

user48420 · Answer

La différence réside dans la manière dont nous stockons les données dans des ordinateurs.

Vous avez raison de dire que pour une machine théorique de 8 bits, nous ne pouvons stocker que 2 ^ 8 valeurs dans un seul registre de processeur ou une seule adresse mémoire. (N'oubliez pas que cela varie d'une "machine" à une "machine" en fonction du processeur utilisé, de l'architecture de la mémoire, etc. Mais pour l'instant, restons avec une machine hypothétique à "stéréotype".)

Pour une machine théorique de 16 bits, la valeur maximale dans un emplacement de registre/mémoire serait de 2 ^ 16, pour une machine de 32 bits, de 2 ^ 32, etc.

Au fil des ans, les programmeurs ont conçu toutes sortes de techniques pour stocker et gérer des nombres plus importants que ceux pouvant être stockés dans un seul registre de processeur ou une seule adresse mémoire. Il existe de nombreuses méthodes, mais elles impliquent toutes l’utilisation de plusieurs adresses de registre/mémoire pour stocker des valeurs supérieures à la largeur de leur emplacement/registre "natif".

Toutes ces méthodes sont bénéfiques en ce que la machine peut stocker/traiter des valeurs supérieures à leur capacité native. L'inconvénient est que presque toutes les approches nécessitent plusieurs instructions/lectures de machine, etc. pour gérer ces chiffres. Pour les grands nombres occasionnels, ce n'est pas un problème. Lorsqu'il s'agit de lots de grands nombres (grandes adresses de mémoire en particulier), le temps système impliqué ralentit les choses.

D'où le désir général de rendre les registres, les emplacements de mémoire et le matériel d'adresse de mémoire "plus larges" et plus larges afin de traiter les grands nombres "de manière native" afin que ces nombres puissent être traités avec un nombre minimal d'opérations.

Étant donné que la taille des nombres est infinie, le registre du processeur/la taille de la mémoire/l'adressage est toujours un équilibre entre la taille native du nombre et les coûts impliqués par la mise en œuvre de largeurs plus grandes et plus grandes.

Adam Davis · Answer

Le but d’un dispositif informatique est généralement d’accepter, de traiter, de stocker et d’émettre des données. Le matériel sous-jacent est simplement une machine permettant d’exécuter ces quatre fonctions. Il ne peut en faire aucun sans logiciel.

Le logiciel est le code qui indique à la machine comment accepter les données, comment les traiter, comment les stocker et comment les transmettre à d'autres.

Le matériel sous-jacent aura toujours des limites. Dans le cas d'une machine 32 bits, la plupart des registres traitant des données ont une largeur de 32 bits seulement. Cela ne signifie toutefois pas que la machine ne peut pas gérer les numéros au-delà de 2 ^ 32, cela signifie que si vous souhaitez traiter des nombres plus importants, il peut prendre plus d'un cycle à la machine pour l'accepter, la traiter, la stocker ou émettez-le.

Le logiciel indique à la machine comment gérer les chiffres. Si le logiciel est conçu pour gérer de grands nombres, il envoie une série d’instructions à la CPU pour lui indiquer comment gérer les grands nombres. Par exemple, votre numéro peut être représenté par deux registres de 32 bits. Si vous souhaitez ajouter 1 234 à votre numéro, le logiciel demande à la CPU d'ajouter d'abord 1 234 au registre inférieur, puis vérifiez le bit de débordement pour voir si cet ajout entraîne un nombre trop grand pour le registre inférieur. Si c'est le cas, alors il ajoute 1 au registre supérieur.

De la même manière que les élèves du primaire apprennent à ajouter avec retenue, il est possible de dire à la CPU de gérer des nombres plus grands que ce qu'elle peut contenir dans un seul registre. Cela est vrai pour la plupart des opérations mathématiques génériques, pour des nombres de toute taille pratique.

Guffa · Answer

Les ordinateurs 32 bits ne peuvent stocker que des entiers signés jusqu'à 2³¹ - 1.
C’est la raison pour laquelle nous n’avons plus d’adresses IPv4 et sommes entrés dans l’ère des 64 bits.

Un ordinateur 32 bits signifie généralement que le bus de données et le bus d’adresses ont une largeur de 32 bits, ce qui signifie que l’ordinateur peut gérer 4 Go d’espace adresse mémoire en une fois et envoyer quatre octets de données à la fois sur le bus de données. .

Cela n'empêche toutefois pas l'ordinateur de gérer plus de données, il lui suffit de diviser les données en blocs de quatre octets lors de leur envoi sur le bus de données.

Le processeur Intel 32 bits standard peut gérer des nombres 128 bits en interne, ce qui vous permet de gérer des nombres tels que 100000000000000000000000000000000000000 sans aucun problème.

Vous pouvez gérer des nombres beaucoup plus grands que ceux d'un ordinateur, mais les calculs doivent être effectués à l'aide d'un logiciel. Le processeur ne dispose pas d'instructions pour la gestion de nombres supérieurs à 128 bits. (Il peut gérer un nombre beaucoup plus grand sous la forme de nombres à virgule flottante, mais vous n'avez alors que 15 chiffres de précision.)

mafu · Answer

Il suffit d'ajouter une note aux nombreuses autres réponses, car il s'agit d'un fait assez important dans cette question qui a été omis.

"32 bits" fait référence à la largeur de l'adresse mémoire. Cela n'a rien à voir avec la taille du registre. Beaucoup de CPU 32 bits ont probablement des registres de 64 ou même de 128 bits. En ce qui concerne plus particulièrement la gamme de produits x86, les processeurs grand public récents, qui sont tous à 64 bits, possèdent des registres jusqu’à 256 bits à des fins particulières.

Cette différence entre la largeur du registre et la largeur de l'adresse existe depuis l'Antiquité, lorsque nous avions des registres à 4 bits et des adresses à 8 bits, ou inversement.

Il est simple de voir que le stockage d'un grand nombre n'est pas un problème, quelle que soit la taille du registre, comme expliqué dans d'autres réponses.

La raison pour laquelle les registres, quelle que soit leur taille, peut également calculer avec des nombres plus grands, est que les calculs trop volumineux peuvent être décomposés en plusieurs plus petits qui entrent dans les registres (c'est juste un petit peu plus compliqué en réalité).

Kyle Strand · Answer

Les réponses déjà données sont en fait plutôt bonnes, mais elles ont tendance à aborder le problème de différents côtés et à présenter ainsi un tableau incomplet. Ils sont aussi un peu trop techniques, à mon avis.

Donc, juste pour clarifier quelque chose qui est suggéré mais qui n’est explicitement exprimé dans aucune des autres réponses, et qui, à mon avis, est le noeud de la question:

Vous mélangez plusieurs concepts dans votre question , et l'un d'entre eux ("32 bits") peut en réalité faire référence à une variété de choses différentes (et différentes réponses ont pris différentes interprétations). Ces concepts ont tous quelque chose à voir avec le nombre de bits (1 et 0) utilisés (ou disponibles) dans divers contextes informatiques (ce que je veux dire par là, espérons-le, sera clarifié par les exemples ci-dessous), mais les concepts sont sinon sans lien de parenté.

Explicitement:

Notez qu'il ne s'agit pas d'une liste complète des interprétations de l'expression "32 bits".

Crédit supplémentaire: pour vraiment voir la distinction philosophique sans faille entre les nombres et les morceaux primitifs de mémoire d'ordinateur, lisez un peu plus sur Les machines de Turing .

Animism · Answer

Si vous souhaitez un exemple concret du nombre de programmes d’un système Linux classique prenant en charge le traitement et la sortie de grands nombres:

libgmp - La GNU bibliothèque arithmétique à précisions multiples est la bibliothèque la plus utilisée à cette fin sur les systèmes Linux. Un exemple simple de multiplication 2 ^ 80 par 1000:

#include <gmp.h> // Each large integer uses the mpz_t type provided by libgmp mpz_t a_large_number; mpz_t base; mpz_t result; // Initalize each variable mpz_init(a_large_number); mpz_init(base); mpz_init(result); // Assign the number 2 to the variable |base| mpz_set_ui(base, 2); // Raise base^80 (2^80), store the result in |a_large_number| mpz_pow_ui(a_large_number, base, 80); // Multiply |a_large_number| by 1000, store the result in |result| mpz_mul_ui(result, a_large_number, 1000); // Finally, output the result in decimal and hex notation gmp_printf("decimal: %Zd, hex: %ZX
", result, result);

Donc, en gros, c’est la même chose que d’utiliser les opérateurs normaux + - * /, avec juste une bibliothèque pour séparer les nombres et les stocker en interne sous forme de nombres de plusieurs machines de la taille d'un mot (c'est-à-dire 32 bits). Il existe également des fonctions de type scanf () pour gérer la conversion de l'entrée de texte en types entiers.

La structure de mpz_t est identique à celle de Scott Chamberlain, qui compte jusqu'à six avec deux mains. Il s’agit en gros d’un tableau de types mp_limb_t de la taille d’une machine Word. Lorsqu'un nombre est trop grand pour tenir dans une machine Word, GMP utilise plusieurs mp_limb_t pour stocker les parties haute/basse du nombre.

Dee · Answer

Si vous écrivez 1000000000000 par exemple dans la calculatrice, l’ordinateur le calculera comme un type réel nombre avec point décimal. La limite pour 32 bits que vous avez mentionnée concerne davantage tous les type entier nombres sans point décimal. Différents types de données utilisent différentes méthodes pour obtenir des bits/octets.

Numéros de type entier: Ce tableau peut vous aider à saisir le point ( http://msdn.Microsoft.com/en-us/library/296az74e.aspx ). Cela touche les limites pour C++. Par exemple, numéro de type Int64} a des limites comprises entre -9223372036854775808 et 9223372036854775807.

Numéros de types réels: Les numéros de types réels contiennent une valeur avec virgule flottante et exposant et vous pouvez entrer des nombres beaucoup plus grands, mais avec une précision et une précision limitées. ( http://msdn.Microsoft.com/en-us/library/6bs3y5ya.aspx ) Par exemple, LDBL (grand double) en C++ a un exposant maximal de 308, vous pouvez donc éventuellement entrer ou avoir comme résultat un nombre 9.999 x 10^308, signifie que vous aurez théoriquement 308 (+1) chiffres de 9, mais seuls les 15 chiffres les plus importants seront utilisés pour le représenter, le reste sera perdu, en raison d'une précision limitée.

En outre, il existe différents langages de programmation et ils peuvent avoir différentes implémentations des limites de nombre. Vous pouvez donc imaginer que des applications spécialisées pourraient gérer des nombres beaucoup plus grands (et/ou plus exacts/précis) que C++.

frodeborli · Answer

Dans votre esprit, vous ne connaissez que 10 chiffres différents. 0 à 9. En interne, dans votre cerveau, cela est certainement codé différemment que dans un ordinateur.

Un ordinateur utilise des bits pour encoder des nombres, mais ce n'est pas important. C'est juste la façon dont les ingénieurs ont choisi d'encoder, mais vous devriez l'ignorer. Vous pouvez penser qu’un ordinateur 32 bits a une représentation unique de plus de 4 milliards de valeurs différentes, alors que nous, les humains, avons une représentation unique de 10 valeurs différentes.

Chaque fois que nous devons comprendre un plus grand nombre, nous utilisons un système. Le nombre le plus à gauche est le plus important. C'est 10 fois plus important que le suivant.

Un ordinateur capable de différencier quatre milliards de valeurs différentes devra de même que la valeur la plus à gauche, dans un ensemble de valeurs, soit quatre milliards de fois plus importante que la valeur suivante de cet ensemble. En fait, un ordinateur ne s'en soucie pas du tout. Il n'attribue pas "d'importance" aux nombres. Les programmeurs doivent créer un code spécial pour s’occuper de cela.

Chaque fois qu'une valeur devient supérieure au nombre de symboles uniques, 9 dans un esprit humain, vous ajoutez un au nombre situé à gauche.

3+3=6

Dans ce cas, le numéro tient toujours dans un seul "emplacement"

5+5=10. This situation is called an overflow.

Les humains ont donc toujours à faire face au problème de ne pas avoir assez de symboles uniques. À moins que l'ordinateur ne dispose d'un système pour gérer cela, il écrit simplement 0, en oubliant qu'il y a un nombre en plus. Heureusement, les ordinateurs ont un "indicateur de débordement" qui est levé dans ce cas.

987+321 is more difficult.

Vous avez peut-être appris une méthode à l'école. Un algorithme. L'algorithme est assez simple. Commencez par ajouter les deux symboles les plus à gauche.

7+1=8, we now have ...8 as the result so far

Ensuite, vous passez à la case suivante et effectuez le même ajout.

8+2=10, the overflow flag is raised. We now have ...08, plus overflow.

Comme nous avons eu un débordement, cela signifie que nous devons ajouter 1 au nombre suivant.

9+3=12, and then we add one due to overflow. ...308, and we had another overflow.

Il n'y a plus de chiffres à ajouter, nous créons donc simplement un emplacement et un insert 1 car l'indicateur de dépassement de capacité a été levé.

Un ordinateur le fait exactement de la même manière, sauf qu’il a 2 ^ 32, voire mieux 2 ^ 64 symboles différents, au lieu de 10 comme l’être humain.

Au niveau matériel, l’ordinateur fonctionne sur des bits uniques en utilisant exactement la même méthode. Heureusement, cela est abstrait pour les programmeurs. Bits ne contient que deux chiffres, car il est facile à représenter dans une ligne électrique. La lumière est allumée ou elle est éteinte.

Enfin, un ordinateur peut afficher n’importe quel nombre sous forme d’une simple séquence de caractères. C'est ce que les ordinateurs sont les meilleurs. L'algorithme de conversion entre une séquence de caractères et une représentation interne est assez complexe.

Rolf · Answer

Parce que vous n’affichez pas un nombre (en ce qui concerne l’ordinateur), mais un string , ou une séquence de chiffres. Bien sûr, certaines applications (comme la calculatrice, je suppose), qui traitent de chiffres, peuvent gérer un tel nombre, je suppose. Je ne sais pas quels trucs ils utilisent ... Je suis sûr que certaines des réponses plus élaborées couvrent cela.

TOOGAM · Answer

La majeure partie du contenu de cette réponse provenait à l'origine de cette réponse (écrite avant que cette autre question ne soit marquée comme un doublon). Je discute donc de l’utilisation de valeurs 8 bits (même si cette question portait sur les valeurs 32 bits), mais c’est acceptable, car les valeurs 8 bits sont plus simples à comprendre conceptuellement et les mêmes concepts s’appliquent aux valeurs plus grandes telles que l’arithmétique 32 bits.

Lorsque vous ajoutez deux nombres de 8 bits, le plus grand nombre que vous pouvez obtenir (0xFF + 0xFF = 1FE). En fait, si vous multipliez deux nombres de 8 bits, le plus grand nombre que vous pouvez obtenir (0xFF * 0xFF = 0xFE01) est toujours de 16 bits, deux fois de 8 bits.

Vous pouvez maintenant supposer qu'un processeur x-bit ne peut garder une trace de x-bits. (Par exemple, un processeur 8 bits ne peut garder qu'une trace de 8 bits.) Ce n'est pas précis. Le processeur à 8 bits reçoit les données en morceaux de 8 bits. (Ces "morceaux" ont généralement un terme formel: un "mot". Sur un processeur 8 bits, des mots de 8 bits sont utilisés. Sur un processeur 64 bits, des mots de 64 bits peuvent être utilisés.)

Ainsi, lorsque vous attribuez à l'ordinateur 3 octets:
Octet 1: L'instruction MUL
Octet n ° 2: les octets de poids fort (par exemple, 0xA5)
Octet n ° 3: les octets de poids faible (par exemple, 0xCB)
L’ordinateur peut générer un résultat supérieur à 8 bits. Le processeur peut générer des résultats comme celui-ci:
0100 0000 0100 0010 xxxx xxxx xxxx xxxx 1101 0111
alias.:
0x4082xxxxD7
Maintenant, laissez-moi vous interpréter cela:
0x signifie simplement que les chiffres suivants sont hexadécimaux.
Je parlerai du "40" plus en détail dans un moment.
82 fait partie du registre "A", qui est une série de 8 bits.
xx et xx font partie de deux autres registres, nommés le registre "B" et le registre "C". La raison pour laquelle je n’ai pas rempli ces bits avec des zéros ou des uns est qu’une instruction "ADD" (envoyée à la CPU) peut faire en sorte que ces bits restent inchangés par l’instruction (alors que la plupart des autres bits que j’utilise dans cet exemple être modifié, à l'exception de quelques-uns des bits de drapeau).
D7 pourrait contenir plus de bits, appelé registre "D".
Un registre n’est qu’un morceau de mémoire. Les registres sont intégrés aux processeurs, ce qui leur permet d'accéder aux registres sans avoir à interagir avec la mémoire stockée sur une clé RAM.

Donc, le résultat mathématique de 0xA5 fois 0xCB est 0x82D7.

Maintenant, pourquoi les bits ont-ils été divisés en registres A et D au lieu des registres A et B, ou des registres C et D? Encore une fois, c’est un exemple de scénario que j’utilise, dont le concept est assez similaire à un vrai langage Assembly (Intel x86 16 bits, utilisé par les processeurs Intel 8080 et 8088 et de nombreux processeurs plus récents). Il peut y avoir des règles communes, telles que le registre "C" étant généralement utilisé comme index pour les opérations de comptage (typique pour les boucles) et le registre "B" utilisé pour garder une trace des décalages permettant de spécifier des emplacements de mémoire. Ainsi, "A" et "D" peuvent être plus communs pour certaines des fonctions arithmétiques communes.

Chaque instruction de la CPU doit avoir une documentation, utilisée par les personnes programmant dans Assembly. Cette documentation doit spécifier quels registres sont utilisés par chaque instruction. (Le choix des registres à utiliser est donc souvent spécifié par les concepteurs de la CPU, et non par les programmeurs du langage Assembly. Cependant, il peut y avoir une certaine flexibilité.)

Revenons maintenant au "40" dans l'exemple ci-dessus: il s'agit d'une série de bits, souvent appelée "registre des drapeaux". Chaque bit du registre de drapeaux a un nom. Par exemple, il existe un bit de "dépassement de capacité" que le CPU peut définir si le résultat est supérieur à l'espace pouvant stocker un octet des résultats. (Le bit "débordement" peut souvent être désigné par l'abréviation de "OF". C'est un o majuscule, pas un zéro.) Le logiciel peut vérifier la valeur de cet indicateur et remarquer le "problème". L'utilisation de ce bit est souvent gérée de manière invisible par les langages de niveau supérieur. Par conséquent, les programmeurs débutants n'apprennent souvent pas comment interagir avec les indicateurs de la CPU. Toutefois, les programmeurs d'assemblage peuvent généralement accéder à certains de ces indicateurs de manière très similaire à d'autres variables.

Par exemple, vous pouvez avoir plusieurs instructions ADD. Une instruction ADD peut stocker 16 bits de résultats dans le registre A et le registre D, tandis qu'une autre instruction peut stocker uniquement les 8 bits de poids faible dans le registre A, ignorer le registre D et spécifier le bit de dépassement. Ensuite, plus tard (après avoir stocké les résultats du registre A dans la RAM principale), vous pourrez utiliser une autre instruction ADD qui stocke uniquement les 8 bits de poids fort dans un registre (éventuellement le registre A). Indiquez si vous devez utiliser un indicateur de dépassement de capacité. dépendez de l’instruction de multiplication que vous utilisez.

(Il existe également couramment un indicateur de "dépassement inférieur", au cas où vous soustrayeriez trop pour tenir dans le résultat souhaité.)

Juste pour vous montrer à quel point les choses se sont compliquées:
Intel 4004 était un processeur 4 bits
L’Intel 8008 était un processeur 8 bits. Il avait des registres 8 bits nommés A, B, C et D.
L’Intel 8086 était un processeur 16 bits. Il avait des registres 16 bits nommés AX, BX, CX et DX.
Le processeur Intel 80386 était un processeur 32 bits. Il possédait des registres 32 bits nommés EAX, EBX, ECX et EDX.
Les processeurs Intel x64 ont des registres 64 bits nommés RAX, RBX, RCX et RDX. Les puces x64 peuvent exécuter du code 16 bits (dans certains modes de fonctionnement) et interpréter des instructions 16 bits. Ce faisant, les bits qui composent le registre AX sont la moitié des bits qui constituent le registre EAX, qui sont la moitié des bits qui constituent le registre RAX. Ainsi, chaque fois que vous modifiez la valeur de AX, vous modifiez également EAX et RAX, car ces bits utilisés par AX font partie des bits utilisés par RAX. (Si vous modifiez EAX avec une valeur multiple de 65 536, les 16 bits inférieurs restent inchangés afin que AX ne change pas. Si vous modifiez EAX avec une valeur qui n'est pas un multiple de 65 536, cela affectera également AX .)

Il y a plus de drapeaux et de registres que ceux que j'ai mentionnés. J'ai simplement choisi des exemples couramment utilisés pour fournir un exemple conceptuel simple.

Maintenant, si vous utilisez un processeur 8 bits, lorsque vous écrivez en mémoire, vous pouvez rencontrer certaines restrictions concernant le fait de pouvoir faire référence à une adresse de 8 bits, et non à une adresse de 4 bits ou 16 bits. Les détails varient en fonction de la CPU, mais si vous avez de telles restrictions, la CPU peut traiter des mots de 8 bits, raison pour laquelle la CPU est plus communément appelée "CPU de 8 bits".