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?

Les ordinateurs 32 bits ne peuvent stocker que des entiers signés allant de 2 ^{31 à} 1.
C'est pourquoi nous sommes à court d'adresses IPv4 et nous 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 nombre 1 billion (1 000 000 000 000) que je semble pouvoir afficher correctement sans que ma machine ne tombe en panne.

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

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 à la deuxième 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.

Vous avez raison de dire qu'un entier 32 bits ne peut contenir une valeur supérieure à 2 ^ 32-1. Toutefois, 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", vous devez disposer de 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 interprété individuellement en tant que caractères ASCII (par exemple, le caractère ' 0' est représenté par la valeur décimale 48, valeur binaire 00110000). être enchaînés dans un format qui a du sens pour vous, un humain.

Un concept connexe en programmation est la conversion de type , qui permet à un ordinateur d’interpréter un flux particulier de 0s et 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 fonctionner avec et traiter en interne un grand nombre de nombres, il existe des entiers 64 bits (pouvant contenir des valeurs pouvant atteindre 16 milliards de milliards), des valeurs à virgule flottante, ainsi que des bibliothèques spécialisées pouvant fonctionner avec des valeurs arbitrairement grandes. Nombres.

D'abord et avant tout, les ordinateurs 32 bits peuvent stocker des nombres allant jusqu'à 2³²-1 dans un seul mot d' ordinateur . Le mot machine est la quantité de données que la CPU peut traiter de manière naturelle (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 CPU 32 bits utilisent des mots de 32 bits et peuvent donc stocker des nombres de 0 à 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 1une fois puis 012 fois, vous tapez du texte. 1entrées 1, 0entré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 ces "nombres", car c’était juste du texte.

La preuve que 1000000000000 n'est pas un nombre mais un texte: il peut représenter 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, il s'agit de la chaîne ) 1000000000000, vous avez besoin de 14 octets (un pour chaque caractère plus un octet NULL de fin qui 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 l' ASCII est utilisé pour le stockage de texte. En mémoire, cela ressemblera à ceci: (convertir les codes ASCII correspondant à 0et 1en binaire, chaque mot sur une ligne séparée)

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é au mot suivant jusqu'à ce que tout (y compris le premier octet NULL) tienne.

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 composé 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 le 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 que des mots simples et doit être implémenté dans un logiciel. L'ajout de la prise en charge de nombres de deux mots de 32 bits à un processeur de 32 bits en fait un processeur de 64 bits (il peut désormais fonctionner en mode natif sur des nombres de 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 ça marche plutôt bien avec hexadécimal )

Vous pouvez également écrire "CETTE DÉCLARATION EST FAUSSE" sans que votre ordinateur ne tombe en panne :) @ La réponse de Scott est exacte pour certains cadres de calcul, mais votre question "d'écrire" un grand nombre implique qu'il s'agit simplement de texte brut, du moins jusqu'à ce que c'est interprété.

Edit: maintenant avec moins de sarcasme, plus d’informations utiles sur les différentes manières de stocker un numéro en mémoire. Je les décrirai avec une abstraction plus élevée, c'est-à-dire en termes qu'un programmeur moderne pourrait écrire du code avant qu'il ne soit traduit en code machine pour exécution.

Les données sur un ordinateur doivent être limitées à un certain type , et une définition informatique de ce type décrit quelles opérations peuvent être effectuées sur ces données et comment (c.-à-d. Comparer des nombres, 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 des 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 nombre entier non signé de 32 bits dans lequel toute valeur de 0à 2^32-1peut ê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, les entiers signés sont 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 entre devoir traiter deux manières d'écrire +0et -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 qu'entre 0et 1, ainsi chaque petit extra utilisé pour la décrire augmenterait sa précision: 1/2, 1/4, 1/8 ... Le problème est que vous ne peut pas exprimer avec précision une simple décimale 0.1sous forme de 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? C'est ce qu'on appelle des nombres à virgule fixe , où nous stockons 1234100mais convenons d'une convention pour le lire comme tel 1234.100.

Un type relativement plus commun utilisé pour les calculs est floating point. 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 y a des normes qui définissent de telles allocations, mais pour un nombre à virgule flottante de 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 ne peut toujours pas fonctionner correctement. Copiez simplement ceci dans la barre d'adresse et appuyez sur Entrée. Alerte spoiler: le résultat ne sera pas 0.3.

javascript:alert(0.1+0.2);

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

La clé est de comprendre comment les ordinateurs encodent les 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 plusieurs méthodes pour les encoder. La norme IEEE 754 définit des règles pour les numéros de codage supérieurs à 2 ^ 32. En gros, les ordinateurs peuvent mettre cela en œuvre en divisant les 32 bits en différentes parties représentant quelques chiffres du nombre et d'autres bits représentant la taille du nombre (c'est-à-dire l'exposant, 10 ^ x). Cela permet une gamme beaucoup plus largedes nombres en termes de taille, mais compromet la précision (ce qui est OK pour de nombreuses fins). Bien entendu, l’ordinateur peut également utiliser plus d’un mot pour cet encodage, ce qui augmente 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 y a beaucoup d'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 à encoder des nombres plus longs. Et vous pouvez jouer avec les résultats dans Excel sans avoir à installer aucun outil de programmation.

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 comme "million", "billion" et plus, alors 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 le système numérique à 10 chiffres, et les ordinateurs, étant électroniques, utilisons le système à 2 chiffres ( binaire ). Les nombres 32 et 64 sont juste des puissances de 2. Il en est de même pour un million et un billion de puissances de 10. 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.

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 (Random Access Memory). Lorsque le processeur ne pouvait gérer que les adresses 16 bits, vous ne pouviez utiliser que 32 Mo de RAM (ce 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 passe 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, ce qui dépend du programme et n'est pas lié à 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.
Remarque secondaire: 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.

Parce que l'affichage du nombre est fait en utilisant des caractères individuels, pas des entiers. Chaque chiffre dans le nombre est représenté par un caractère littéral séparé, dont la valeur entière est définie par le codage utilisé, par exemple , 'a'est représentée avec une valeur ASCII 97, tandis que '1'est représenté avec 49. Vérifiez la table ascii ici .
Pour afficher à la fois "a" et "1" est identique. 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é. La quantité de caractères distincts qu’ils peuvent afficher dépend de la RAM dont vous disposez. Si vous ne disposez que d'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 ce ne soit pas entièrement lié aux ordinateursbit-size, il 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.

Déni de responsabilité: 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 sur la raison pour laquelle il ne plante pas le PC.

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 à la commande (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. Les jeux d'instructions SSE et 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 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 mémoire, mot de registre, mot de bus, etc.) ne sont pas connectés les uns aux autres, sinon ils ont un diviseur commun de 8, 16 ou 24. De nombreux processeurs ont même utilisé un mot de 6 bits (mais son historique).

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 qu’elle ne 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.

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 de registre / mémoire "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 le grand nombre occasionnel, ce n'est pas un problème. Lorsque vous traitez avec beaucoup 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 gérer des nombres importants de manière "native" afin que ces nombres puissent être géré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 du nombre natif et les coûts impliqués par la mise en œuvre de largeurs de plus en plus grandes.

Les ordinateurs 32 bits ne peuvent stocker que des nombres allant jusqu'à 2 ^ 32 dans un seul mot d'ordinateur, mais cela ne signifie pas qu'ils ne peuvent pas gérer de plus grandes entités de données.

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 ensuite ê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 ne disposez que de 15 chiffres de précision.)

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 être calculée avec des nombres plus grands, est que des calculs trop volumineux peuvent être décomposés en plusieurs plus petits qui entrent dans les registres (c’est un peu plus compliqué en réalité).

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, je pense, 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 supposé 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 n'ont pas de relation .

Explicitement:

• "IPv4 / 6" désigne le protocole Internet , un ensemble de règles définissant la manière dont les informations doivent être empaquetées et interprétées sur Internet. La principale distinction (ou du moins la plus connue) entre IPv4 et IPv6 est que l' espace d'adressage (c'est-à-dire l'ensemble d'adresses pouvant être utilisé pour distinguer différents emplacements sur le réseau) est plus grand dans IPv6. Cela concerne le nombre de bits de chaque paquet de données envoyé sur le réseau qui sont alloués (c.-à-d. Mis de côté afin d'identifier) ​​l'expéditeur et le destinataire du paquet.
  • Analogie non-informatique: chaque paquet est semblable à une lettre envoyée par courrier postal et l'espace d'adressage est équivalent au nombre de caractères que vous "êtes autorisé" à utiliser lors de l'écriture de l'adresse et de l'adresse de retour sur l'enveloppe.
  • Je ne vois pas cela mentionné dans aucune des autres réponses jusqu'à présent.
• Les "mots" de mémoire d'ordinateur (32 bits et 64 bits) peuvent généralement être considérés comme la plus petite donnée utilisée par un ordinateur, ou "réfléchie". Ces bits de données s'unissent pour constituer d'autres bits de données. , tels que des morceaux de texte ou des entiers plus grands.
  • Analogie non-informatique: les mots peuvent être considérés un peu comme des lettres constituant des mots sur du papier, ou même comme des mots individuels dans un train de pensées.
  • Voir la réponse de Guffa , la réponse de sanaris , et le premier paragraphe de la réponse de gronostaj .
• Les pointeurs 32 bits peuvent ou non être des mots, mais ils sont néanmoins traités de manière atomique (c'est-à-dire comme des unités individuelles qui ne peuvent pas être décomposées en composants plus petits). Les pointeurs représentent la manière la plus simple dont un ordinateur peut enregistrer l’emplacement en mémoire d’un bloc de données arbitraire. Notez que la taille du pointeur utilisé par l'ordinateur (ou, en réalité, par le système d'exploitation) limite la plage de mémoire accessible par un seul pointeur, car il n'y a qu'un nombre maximal d'emplacements mémoire possibles sur lesquels un pointeur peut "pointer". comme il existe des valeurs possibles pour le pointeur lui-même. Ceci est analogue à la manière dont IPv4 limite la plage d'adresses Internet possibles, mais ne paslimiter la quantité de données pouvant être présente, par exemple, sur une page Web donnée. Cependant, la taille du pointeur ne limite pas la taille des données sur lesquelles le pointeur peut pointer. (Pour un exemple de schéma permettant à la taille des données de dépasser la plage du pointeur, consultez la structure du pointeur inode de Linux . Notez qu'il s'agit d'une utilisation légèrement différente du mot "pointeur" par rapport à ce qui est typique, car le pointeur fait généralement référence à un pointeur dans. mémoire vive, pas d’espace disque.)
  • Analogie non-informatique: hmmmm ... celle-ci est un peu délicate. Peut-être que le système décimal de Dewey pour l’indexation des documents de bibliothèque est un peu similaire? Ou tout système d'indexation, vraiment.
  • Voir la réponse de SiteNook .
  • S'il vous plaît noter que mon explication des pointeurs ci-dessus élides quelques détails subtils et est sans doute pas tout à fait correct. Cependant, dans les langages de programmation dans lesquels les programmeurs travaillent directement avec des pointeurs, le mode mental que j'ai dessiné est généralement suffisant pour des raisons pratiques.
• Les nombres qu'un ordinateur est "capable d'afficher" ne sont pas (pour des raisons pratiques) limités par le matériel ou le système d'exploitation de l'ordinateur; ils sont traités comme n'importe quel autre texte.
  • Analogie non-informatique: écrire sur un morceau de papier
  • Voir la réponse de l'utilisateur1306322 et la réponse de Bigbio2002

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 .

Si vous écrivez 1000000000000 par exemple dans la calculatrice, l'ordinateur le calculera comme un nombre de type réel avec un point décimal . La limite pour 32 bits que vous avez mentionnée concerne davantage tous les nombres de type Integer 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 à comprendre le point ( http://msdn.microsoft.com/en-us/library/296az74e.aspx ). Cela touche les limites pour C ++. Par exemple, le numéro de type Int64 a des limites allant de -9223372036854775808 à 9223372036854775807.

Chiffres de type réels : Les numéros de types réels contiennent des valeurs avec virgule flottante et exposant . Vous pouvez entrer des nombres beaucoup plus grands, mais avec une précision limitée. ( 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 un nombre de résultats 9.999 x 10^308qui signifie avoir théoriquement 308 (+1) chiffres 9mais seulement 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 ++.

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 bibliothèque arithmétique à précision multiple GNU est la bibliothèque la plus largement utilisée à cette fin sur les systèmes Linux. Un exemple simple de multiplier 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\n", result, result);

En gros, cela revient à 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 mots de la machine (c.-à-d. 32 bits). Il existe également des fonctions de type scanf () permettant de gérer la conversion d’entrée de texte en types entiers.

La structure de mpz_test exactement comme celle de Scott Chamberlain, qui compte jusqu'à six à l'aide de deux mains. Il s’agit essentiellement d’un ensemble de mp_limb_ttypes de mots de la taille d’une machine , et lorsqu'un nombre est trop grand pour tenir dans un mot machine, GMP en utilise plusieurs mp_limb_tpour stocker les parties haute / basse du nombre.

Dans votre esprit, vous ne connaissez que 10 chiffres différents. De 0 à 9. En interne, cela est codé différemment dans votre cerveau 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 également faire en sorte 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 permettant de 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é.

1308

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.

Parce que vous n’affichez pas un nombre (en ce qui concerne l’ordinateur), mais une chaîne 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.

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 3 octets à l'ordinateur:
Octet n ° 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 est plus de 8 bits. Le processeur peut générer des résultats comme celui-ci:
0100 0000 0100 0010 xxxx xxxx xxxx xxxx 1101 0111
aka:
0x4082xxxxD7 Je vais
maintenant interpréter cela pour vous:
0x signifie simplement que les chiffres suivants sont hexadécimaux.
Je vais discuter du "40" plus en détail dans un instant.
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 soient 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é le registre "D".
Un registre est juste 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 d'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 à celui d’un véritable 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" 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: c’est une série de bits, souvent appelée "registre des drapeaux". Chaque bit du registre de drapeaux a un nom. Par exemple, il y a 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. Cependant, 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 simplement stocker les 8 bits inférieurs 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:
le processeur Intel 4004 était un processeur 4 bits.
Le processeur Intel 8008 était un processeur 8 bits. Il avait des registres 8 bits nommés A, B, C et D.
Le processeur 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 possèdent 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. AX ne changera donc 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".