Si les machines 32 bits ne peuvent traiter que les nombres jusqu'à 2^32, pourquoi puis-je écrire 1000000000000 (trillion) sans que ma machine ne plante ?

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

Comment comptez-vous sur vos doigts jusqu'à 6 ?

Vous comptez probablement jusqu'au plus grand nombre possible avec une main, puis vous passez à la deuxième main lorsque vous manquez de doigts. Les ordinateurs font la même chose, s'ils doivent représenter une valeur supérieure à ce que peut contenir un seul registre, ils utiliseront plusieurs blocs de 32 bits pour travailler avec les données.

Vous avez raison de dire qu'un nombre entier de 32 bits ne peut pas avoir une valeur supérieure à 2^32-1. Cependant, la valeur de cet entier de 32 bits et la façon dont il apparaît sur votre é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 individuel peut contenir une valeur allant jusqu'à 255. Aucun d'entre eux ne peut contenir la valeur numérique entière, mais interprétés individuellement comme des caractères ASCII (par exemple, le caractère “0” est représenté par la valeur décimale 48, la valeur binaire 00110000), ils peuvent être liés ensemble dans un format qui a un sens pour vous, un humain.

Un concept connexe en programmation est le typecasting, qui est la façon dont un ordinateur interprétera 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, voire même quelque chose d'entièrement différent. Alors qu'un entier de 32 bits ne peut pas contenir une valeur de 1000000000000, un nombre à virgule flottante de 32 bits le pourra, en utilisant une interprétation entièrement différente.

Quant à la façon dont les ordinateurs peuvent travailler et traiter de grands nombres en interne, il existe des entiers de 64 bits (qui peuvent contenir des valeurs allant jusqu'à 16 milliards de milliards), des valeurs à virgule flottante, ainsi que des bibliothèques spécialisées qui peuvent travailler avec des nombres arbitrairement grands.

Avant tout, les ordinateurs 32 bits peuvent stocker des nombres allant jusqu'à 2³²-1 en un seul mot machine. Mot machine est la quantité de données que l'unité centrale peut traiter de manière naturelle (c'est-à-dire que les opérations sur des données de cette taille sont implémentées dans le matériel et sont généralement plus rapides à exécuter). Les CPU 32 bits utilisent des mots composés de 32 bits, ils peuvent donc stocker des nombres de 0 à 2³²-1 en un seul mot.

• 1 trillion_ et 1000000000000 sont deux choses différentes.

• 1 trillion est un concept abstrait de nombre

• 1000000000000 est du texte

En appuyant une fois sur 1 puis 0 12 fois, vous tapez du texte. 1 entrées 1, 0 entrées 0. Vous voyez ? Vous tapez des caractères. Les caractères ne sont pas des chiffres. Les machines à écrire n'ont pas de CPU ni de mémoire du tout et elles gèrent plutôt bien ces “nombres”, car ce n'est que du texte.

Preuve que 1000000000000 n'est pas un nombre, mais du texte: il peut signifier 1 trillion (en décimal), 4096 (en binaire) ou 281474976710656 (en hexadécimal). Il a encore plus de significations dans différents systèmes. La signification de 1000000000000 est un nombre et son stockage est une autre histoire (nous y reviendrons dans un instant).

Pour stocker le texte (en programmation, il s'appelle string) 1000000000000, il faut 14 octets (un pour chaque caractère plus un octet NULL de terminaison qui signifie en gros “la chaîne se termine ici”). Cela fait 4 mots machine. 3 et demi seraient suffisants, mais comme je l'ai dit, les opérations sur les mots machines sont plus rapides. Supposons que ASCII soit utilisé pour le stockage de texte, donc en mémoire cela ressemblera à ceci : (conversion des codes ASCII correspondant à 0 et 1 en 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 entrent dans un mot, le reste est déplacé vers le suivant. Le reste est déplacé vers le mot suivant jusqu'à ce que tout (y compris le premier octet NULL) tienne.

Maintenant, retour au stockage des nombres. Cela fonctionne comme pour le texte débordant, 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 le décimal au lieu du binaire
• un octet peut contenir des nombres 0..9
• un mot est constitué de deux octets

Voici une mémoire vide de deux mots :

0 0
0 0

Stockons le nombre 4 :

0 4
0 0

Ajoutons maintenant 9 :

1 3
0 0

Remarquez que les deux opérandes tiendraient dans un octet, mais pas le résultat. Mais nous en avons un autre prêt à l'emploi. Stockons maintenant 99 :

9 9
0 0

Une fois de plus, nous avons utilisé le deuxième octet pour stocker le nombre. Ajoutons 1 :

0 0
0 0

Whoops… Cela s'appelle débordement d'entier et est à l'origine de nombreux problèmes graves, parfois très coûteux .

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

0 0
9 9

Et maintenant ajoutez 1 :

0 1
0 0

Il devient plus clair si vous supprimez les espaces de séparation d'octets et les lignes de retour :

0099 | +1
0100

Nous avons prédit que ce débordement pourrait se produire et que nous pourrions avoir besoin de mémoire supplémentaire. Le traitement des chiffres de cette manière n'est pas aussi rapide que celui des chiffres qui tiennent dans un seul mot et il doit être mis en œuvre dans un logiciel. L'ajout de la prise en charge des nombres de deux mots de 32 bits à un CPU de 32 bits en fait effectivement un CPU de 64 bits (il peut maintenant fonctionner sur des nombres de 64 bits en natif, non ?).

Tout ce que j'ai décrit ci-dessus s'applique à la mémoire binaire avec des mots de 8 bits et de 4 octets aussi, 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 ces nombres en système décimal est cependant délicate. (mais cela fonctionne assez bien avec le système hexadécimal )

Vous pouvez également écrire “CETTE DÉCLARATION EST FAUSSE” sans que votre ordinateur ne plante :) La réponse de Scott est parfaite pour certains cadres de calcul, mais votre question d’“écrire” un grand nombre implique que ce n'est que du texte simple, du moins jusqu'à ce qu'il soit interprété.

Edit: maintenant avec moins de sarcasme plus d'informations utiles sur les différentes façons dont un nombre peut être stocké en mémoire. Je vais les décrire avec une plus grande abstraction, c'est-à-dire en des termes dans lesquels un programmeur moderne peut écrire du code avant qu'il ne soit traduit en code machine pour être exécuté.

Les données d'un ordinateur doivent être limitées à un certain type, et une définition informatique de ce type décrit les opérations qui peuvent être effectuées sur ces données et comment (c'est-à-dire 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, de sorte que certaines de ces valeurs peuvent être converties entre types.

Commençons par les nombres entiers non signés. Dans ces types de valeurs, tous les bits sont utilisés pour stocker des informations sur les chiffres ; le vôtre est un exemple d'un 32-bit unsigned integer où toute valeur de 0 à 2^32-1 peut être stockée. Et oui, selon le langage ou l'architecture de la plate-forme utilisée, vous pourriez avoir des entiers de 16 bits ou de 256 bits.

Et si vous voulez obtenir des valeurs négatives ? Intuitivement, signed integers est le nom du jeu. La convention est d'attribuer toutes les valeurs de -2^(n-1) à 2^(n-1)-1 - de cette façon, nous évitons la confusion de devoir composer avec deux façons d'écrire +0 et -0. Ainsi, un entier signé de 32 bits contiendra une valeur de -2147483648 à 2147483647. Bien, 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 se situer qu'entre 0 et 1, donc chaque bit supplémentaire utilisé pour la décrire augmenterait sa précision : ½, ¼, 1/8… Le problème est que vous ne pouvez pas exprimer avec précision une simple décimale 0.1 comme une somme de fractions qui ne peuvent avoir que des puissances de deux dans leur dénominateur ! Ne serait-il pas beaucoup plus facile de stocker le nombre comme un entier, mais d'accepter de mettre le point (décimal) à la place ? C'est ce qu'on appelle les nombres à point fixe, où on stocke 1234100 mais on se met d'accord sur une convention pour le lire comme 1234.100 à la place.

Un type relativement plus courant utilisé pour les calculs est floating point. Son fonctionnement est très soigné : il utilise un bit pour stocker la valeur du signe, puis un autre pour stocker l'exposant et le significand. Il existe des normes qui définissent de telles attributions, mais pour un 32-bit float le nombre maximum que vous pourriez stocker est un

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

Cela se fait toutefois au prix de la précision. Le JavaScript disponible dans les navigateurs utilise des flotteurs de 64 bits, et il ne peut toujours pas faire les choses correctement. Il suffit de le copier dans la barre d'adresse et d'appuyer sur la touche Entrée. Alerte spoiler : le résultat est non va être 0.3.

javascript:alert(0.1+0.2);

Il y a d'autres types d'alternatives comme les .NET 4.5 de Microsoft BigInteger , qui n'ont théoriquement pas de limites supérieures ou inférieures et doivent être calculés par “lots” ; mais peut-être les technologies les plus fascinantes sont celles qui comprennent les mathématiques, comme le moteur de Wolfram Mathematica, qui peut fonctionner précisément avec des valeurs abstraites comme infini .

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

Vrai, si un ordinateur insiste pour stocker des nombres en utilisant une simple représentation binaire du nombre à l'aide d'un seul mot (4 octets sur un système 32 bits), alors un ordinateur 32 bits ne peut stocker que des nombres jusqu'à 2^32. Mais il existe de nombreuses autres façons d'encoder les nombres en fonction de ce que l'on veut en faire.

Un exemple est la façon dont les ordinateurs stockent les nombres à virgule flottante. Les ordinateurs peuvent utiliser tout un tas de méthodes différentes pour les coder. La norme IEEE 754 définit des règles pour l'encodage de nombres supérieurs à 2^32. En gros, les ordinateurs peuvent mettre cela en œuvre en divisant les 32 bits en différentes parties représentant certains chiffres du nombre et d'autres bits représentant la taille du nombre (c'est-à-dire l'exposant, 10^x). Cela permet d'obtenir une gamme de nombres beaucoup plus grande en termes de taille, mais cela compromet la précision (qui est acceptable dans de nombreux cas). Bien sûr, l'ordinateur peut aussi utiliser plus d'un mot pour ce codage, ce qui augmente la précision de la magnitude des nombres codés disponibles. La version 32 décimale simple de la norme IEEE permet des nombres avec environ 7 chiffres décimaux de précision et des nombres d'une magnitude allant jusqu'à environ 10^96.

Mais il existe de nombreuses autres options si vous avez besoin d'une précision supplémentaire. Vous pouvez évidemment utiliser plus de mots dans votre encodage sans limite (mais avec une pénalité de performance pour convertir dans et hors du format encodé). Si vous voulez explorer une façon de le faire, il existe un excellent add-in open-source pour Excel qui utilise un schéma d'encodage permettant des centaines de chiffres de précision dans le calcul. Cet add-in 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 d'outils de programmation.

Tout est dans votre question.

Vous pouvez écrire le nombre que vous voulez sur le papier. Essayez d'écrire un trillion de points sur une feuille blanche. C'est lent et inefficace. C'est pourquoi nous avons un système à 10 chiffres pour représenter ces grands nombres. Nous avons même des noms pour les grands nombres comme “million”, “trillion” et plus, pour que vous ne disiez pas one one one one one one one one one one one... à voix haute.

Les processeurs 32 bits sont conçus pour fonctionner le plus rapidement et le plus efficacement possible avec des blocs de mémoire qui font exactement 32 chiffres binaires. Mais nous, les gens, utilisons couramment un système numérique à 10 chiffres, et les ordinateurs, étant électroniques, utilisent un système à 2 chiffres binaire ). Les nombres 32 et 64 se trouvent être des puissances de 2, tout comme un million et un trillion sont des puissances de 10. Il est plus facile pour nous de travailler avec ces nombres qu'avec des multitudes de 65536, par exemple.

Nous décomposons les grands 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 le nombre que nous voulons, tout comme les ordinateurs si nous les concevons ainsi.

32 bits et 64 bits font référence aux adresses de mémoire. La mémoire de votre ordinateur est comme les boîtes postales, chacune d'entre elles ayant une adresse différente. L'unité centrale de traitement (CPU) utilise ces adresses pour adresser les emplacements mémoire de votre RAM (Random Access Memory). Lorsque l'unité centrale ne pouvait traiter que des adresses de 16 bits, vous ne pouviez utiliser que 32 Mo de mémoire vive (ce qui semblait énorme à l'époque). Avec 32 bits, on passait à 4+gb (ce qui semblait énorme à l'époque). Maintenant que nous avons des adresses de 64 bits, la RAM passe à des téraoctets (ce qui semble énorme). Cependant, le programme est capable d'allouer plusieurs blocs de mémoire pour des choses comme le stockage de nombres et de texte, c'est à la discrétion du programme et sans rapport avec la taille de chaque adresse. Ainsi, un programme peut dire à l'unité centrale, je vais utiliser 10 blocs d'adresses de stockage et ensuite stocker un très grand nombre, ou une chaîne de 10 lettres ou autre. Note : Les adresses de mémoire sont pointées par des “pointeurs”, donc la valeur 32 et 64 bits signifie la taille du pointeur utilisé pour accéder à la mémoire.

Parce que l'affichage du nombre se fait à l'aide de caractères individuels, et non d'entiers. Chaque chiffre du nombre est représenté par un caractère littéral distinct, dont la valeur entière est définie par le codage utilisé, par exemple 'a' est représenté avec la valeur ascii 97, tandis que '1' est représenté avec 49. Vérifiez le tableau ascii ici . Pour l'affichage, “a” et “1” sont identiques. Ce sont des caractères littéraux, et non des entiers. Chaque caractère littéral peut avoir une valeur maximale de 255 sur une plate-forme 32 bits, en stockant la valeur sur 8 bits ou sur 1 octet (cela dépend de la plate-forme, mais 8 bits est la taille de caractère la plus courante), ce qui permet de les regrouper et de les afficher. La quantité de caractères séparés qu'ils peuvent afficher dépend de la mémoire vive dont vous disposez. Si vous avez seulement 1 octet de RAM, vous pouvez afficher un seul caractère, si vous avez 1 Go de RAM, vous pouvez afficher 1024 caractères (trop paresseux pour faire le calcul). Cette limitation s'applique cependant aux calculs, mais je suppose que vous êtes intéressé par la norme IPV4. Bien qu'elle ne soit pas entièrement liée aux ordinateurs bit-size, elle a en quelque sorte affecté les normes. Lorsque la norme IPV4 a été créée, les valeurs ip ont été stockées dans des entiers de 32 bits. Une fois que vous avez donné la taille, elle est devenue la norme. Tout ce que nous savons sur Internet en dépendait, et nous n'avions plus d'adresses IP à attribuer. Donc, si la norme IP a été révisée pour avoir 64 bits, tout va s'arrêter de fonctionner, y compris votre routeur (je suppose que c'est correct) et les autres appareils de réseau. Il faut donc créer une nouvelle norme, qui remplace simplement l'entier 32 bits par un entier 128 bits. Et le reste de la norme a été ajusté. Les fabricants de matériel doivent juste déclarer qu'ils soutiennent cette nouvelle norme et cela deviendra viral. Bien que ce ne soit pas si simple, je suppose que vous avez compris.

Disclaimer: La plupart des points mentionnés ici sont fidèles à mon hypothèse. J'ai peut-être omis des points importants ici pour simplifier les choses. Je ne suis pas doué pour les chiffres, j'ai donc dû en oublier certains, mais mon but ici est de répondre à la réponse de l'OP sur les raisons pour lesquelles il ne plantera pas le PC.

Dans les processeurs, il y a des “mots”. Il y a des mots différents. Lorsque les gens disent “processeur 32 bits”, ils veulent surtout dire “largeur de bus mémoire”. Ce mot est constitué de différents “champs”, qui se réfèrent à des sous-systèmes de l'ordinateur correspondant à la transmission (24 bits) et au contrôle (autres bits). Je peux me tromper sur les chiffres exacts, assurez-vous en par des 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 il s'agit toujours d'un multiple de 64 bits.

Les processeurs Opteron actuels peuvent traiter des nombres de 256 bits de large (je ne suis pas sûr pour les entiers, mais le flottement est certain).

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

L'objectif d'un appareil 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 qui aide à remplir ces quatre fonctions. Le logiciel est le code qui indique à la machine comment accepter des données, comment les traiter, comment les stocker et comment les fournir à d'autres. Le matériel sous-jacent aura toujours des limites. Dans le cas d'une machine 32 bits, la plupart des registres qui traitent les données ne font que 32 bits de large. Cela ne veut pas dire, cependant, que la machine ne peut pas traiter des nombres au-delà de 2^32, cela signifie que si vous voulez traiter des nombres plus importants, la machine peut avoir besoin de plus d'un cycle pour les accepter, les traiter, les stocker ou les émettre.

Le logiciel indique à la machine comment traiter les nombres. Si le logiciel est conçu pour traiter de grands nombres, il envoie une série d'instructions à l'unité centrale qui lui indique comment traiter les grands nombres. Par exemple, votre nombre peut être représenté par deux registres de 32 bits. Si vous souhaitez ajouter 1 234 à votre nombre, le logiciel demandera à l'unité centrale d'ajouter d'abord 1 234 au registre inférieur, puis de vérifier le bit de débordement pour voir si cet ajout a donné un nombre trop grand pour le registre inférieur. Si c'est le cas, il ajoute alors 1 au registre supérieur.

De la même manière que l'on apprend aux élèves de l'école primaire à ajouter avec un carry, on peut dire à l'unité centrale de traiter des nombres plus grands que ce qu'elle peut contenir dans un seul registre. Ceci est vrai pour la plupart des opérations mathématiques génériques, pour des nombres de toute taille pratique.

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

La signification d'un ordinateur 32 bits est 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 mémoire d'adresses à la fois, et envoyer quatre octets de données à la fois sur le bus de données. Cela n'empêche pas l'ordinateur de traiter plus de données, il doit simplement les diviser en quatre octets lorsqu'il les envoie sur le bus de données. Le processeur 32 bits d'Intel peut traiter des nombres de 128 bits en interne, ce qui vous permet de traiter des nombres comme 10000000000000000000000000000000000 sans aucun problème.

Vous pouvez traiter des nombres beaucoup plus importants que cela dans un ordinateur, mais les calculs doivent alors être effectués par un logiciel, le CPU n'a pas d'instructions pour traiter des nombres supérieurs à 128 bits. (Elle peut traiter des nombres beaucoup plus importants sous forme de nombres à virgule flottante, mais alors vous n'avez que 15 chiffres de précision).

J'ajoute juste une note aux nombreuses autres réponses, parce que c'est un fait assez important dans cette question qui a été manquée.

“32 bit” fait référence à la largeur de l'adresse mémoire. Cela n'a rien à voir avec la taille du registre. De nombreux CPU 32 bits ont probablement des registres de 64 ou même 128 bits. En particulier, en ce qui concerne la gamme de produits x86, les CPU grand public récents, qui sont tous à 64 bits, possèdent des registres de 256 bits pour des usages particuliers.

Cette différence entre la largeur de registre et la largeur d'adresse existe depuis l'Antiquité, lorsque nous avions des registres de 4 bits et des adresses de 8 bits, ou vice versa. La raison pour laquelle les registres, quelle que soit leur taille, peuvent également calculer avec des nombres plus importants, est que des calculs trop importants peuvent être décomposés en plusieurs calculs plus petits qui s'intègrent dans les registres (c'est juste un peu plus compliqué en réalité).

Les réponses déjà données sont en fait assez bonnes, mais elles ont tendance à aborder la question sous différents angles et présentent donc une image incomplète. Elles sont également un peu trop techniques, à mon avis.

Donc, juste pour clarifier quelque chose qui est suggéré mais pas explicitement exprimé dans les autres réponses, et qui, je pense, est le cœur du problème :

Vous mélangez plusieurs concepts dans votre question, et l'un d'entre eux (“32 bits”) peut en fait se référer à 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 j'entends par là sera, je l'espère, clarifié par les exemples ci-dessous), mais les concepts sont autrement sans rapport.

Explicitement :

• “IPv4/6” fait référence au protocole internet , un ensemble de règles définissant comment les informations doivent être présentées et interprétées sur l'internet. La principale (ou du moins la plus connue) distinction entre IPv4 et IPv6 est que le espace d'adressage (c'est-à-dire l'ensemble des adresses qui peuvent être utilisées pour distinguer les différents emplacements sur le réseau) est plus grand dans IPv6. Cela a trait au nombre de bits de chaque paquet de données envoyé sur le réseau qui sont alloués pour (c'est-à-dire mis de côté dans le but de) identifier l'expéditeur et le destinataire du paquet.
• Analogie non informatique : Chaque paquet est comme une lettre envoyée par courrier postal, et l'espace d'adresse est comme la quantité de caractères que vous êtes “autorisé” à utiliser lorsque vous écrivez l'adresse et l'adresse de retour sur l'enveloppe.
• Je ne vois pas cela mentionné dans les 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 le plus petit élément de données qu'un ordinateur utilise, ou “pense”. Ces bits de données s'assemblent pour former 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 composant des mots sur papier, ou même comme des mots individuels dans un train de pensée.
• 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 plus petites composantes). Les pointeurs sont le moyen de niveau le plus bas par lequel un ordinateur peut enregistrer l'emplacement en mémoire d'un bloc de données arbitraire. Notez que la taille du pointeur utilisée 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'autant d'emplacements mémoire possibles vers lesquels un pointeur peut “pointer” qu'il y a de valeurs possibles pour le pointeur lui-même. Cela est analogue à la façon dont IPv4 limite la gamme des adresses internet possibles, mais ne limite pas la quantité de données qui peuvent être présentes, par exemple, dans une page web particulière. Cependant, la taille du pointeur ne limite pas la taille des données elles-mêmes vers lesquelles le pointeur peut pointer. (Pour un exemple de schéma permettant à la taille des données de dépasser la portée du pointeur, consultez la structure de pointeur inode de Linux inode pointer structure . Notez qu'il s'agit d'une utilisation du mot “pointeur” légèrement différente de celle qui est habituelle, puisque le terme “pointeur” fait généralement référence à un pointeur dans une mémoire vive, et non à l'espace du disque dur).
• 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 n'importe quel système d'indexation, en fait.
• Voir Réponse de SiteNook .
• Veuillez noter que mon explication des pointeurs ci-dessus élude certains détails subtils et n'est sans doute pas tout à fait correcte. 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 user1306322 et Bigbio2002

Notez que ceci n'est pas une liste exhaustive d'interprétations de l'expression “32 bits”.

Crédit supplémentaire : pour vraiment voir la distinction philosophique entre les nombres et les morceaux primitifs de mémoire informatique, lisez un peu sur Turing machines .

Dans votre esprit, vous ne connaissez que 10 chiffres différents. 0 à 9. Dans votre cerveau, ces chiffres sont certainement codés différemment que dans un ordinateur.

Un ordinateur utilise des bits pour coder les chiffres, mais ce n'est pas important. C'est juste la façon dont les ingénieurs ont choisi d'encoder les choses, mais vous devriez ignorer cela. 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 pour 10 valeurs différentes.

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

Un ordinateur capable de différencier quatre milliards de valeurs différentes, devra de la même façon 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 dans cet ensemble. En fait, un ordinateur ne s'en soucie pas du tout. Il n'accorde pas d’“importance” aux chiffres. Les programmeurs doivent créer un code spécial pour s'en occuper.

Chaque fois qu'une valeur devient plus grande que le nombre de symboles uniques, 9 dans l'esprit d'un humain, vous ajoutez un au nombre de gauche.

3+3=6

Dans ce cas, le nombre tient toujours dans un seul “slot”

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

Donc les humains sont toujours confrontés au problème du manque de symboles uniques. À moins que l'ordinateur ne dispose d'un système pour traiter ce problème, il se contenterait d'écrire 0, oubliant qu'il y a un nombre supplémentaire. Heureusement, les ordinateurs ont un “drapeau 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

Puis vous passez au créneau suivant et effectuez la même addition.

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

Puisque 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 nombres à ajouter, donc nous créons simplement un créneau et nous insérons 1 parce que le drapeau de débordement a été levé.

1308

Un ordinateur fait exactement la même chose, sauf qu'il a 2^32 ou mieux encore 2^64 symboles différents, au lieu de seulement 10 comme les humains.

Au niveau matériel, l'ordinateur travaille sur des bits uniques en utilisant exactement la même méthode. Heureusement, les programmeurs n'ont pas à s'en soucier. Les bits ne comportent que deux chiffres, parce que c'est facile à représenter sur une ligne électrique. Soit la lumière est allumée, soit elle est éteinte.

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

Au cas où vous souhaiteriez un exemple pratique du nombre de programmes sur un système Linux typique qui traitent et produisent de grands nombres :

libgmp - The GNU Multiple Precision Arithmetic Library est la bibliothèque la plus largement utilisée à cette fin sur les systèmes Linux. Un exemple simple de multiplication de 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);

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

La structure de mpz_t est exactement comme l'exemple de Scott Chamberlain qui compte jusqu'à 6 en utilisant deux mains. Il s'agit essentiellement d'un tableau de types mp_limb_t de la taille d'un mot machine, et lorsqu'un nombre est trop grand pour tenir dans un mot machine, GMP utilise plusieurs mp_limb_t pour stocker les parties hautes/basses du nombre.

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

Nombre de type entier : Ce tableau pourrait vous aider à saisir le point http://msdn.microsoft.com/en-us/library/296az74e.aspx ). Cela touche aux limites pour le C++. Par exemple, le numéro de type Int64 a des limites allant de -9223372036854775808 à 9223372036854775807.

Numéros de type réel : Les numéros de type réel contiennent des valeurs avec point flottant et exposant et vous pouvez entrer des nombres beaucoup plus grands, mais avec une précision/exactitude limitée. http://msdn.microsoft.com/en-us/library/6bs3y5ya.aspx ) Par exemple, LDBL (large double) en C++ a un exposant maximum de 308, donc vous pouvez éventuellement entrer ou avoir comme résultat le nombre 9.999 x 10^308, ce qui signifie que vous aurez théoriquement 308(+1) chiffres de 9 mais seulement 15 chiffres les plus importants seront utilisés pour le représenter, le reste sera perdu, cause d'une précision limitée.

De plus, il existe différents langages de programmation et ils pourraient avoir différentes implémentations des limites de nombres. Vous pouvez donc imaginer que des applications spécialisées pourraient traiter des nombres beaucoup plus importants (et/ou plus exacts/précis) que le C++.

Parce que vous n'affichez pas un numéro (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 des nombres, peuvent traiter un tel nombre, je suppose. Je ne sais pas quelles astuces ils utilisent… Je suis sûr que d'autres réponses plus élaborées couvrent ce point.

La majeure partie du contenu de cette réponse provient à l'origine de cette réponse (écrite avant que l'autre question ne soit marquée comme un double). Je parle donc d'utiliser des valeurs de 8 bits (même si cette question portait sur des valeurs de 32 bits), mais cela ne pose pas de problème car les valeurs de 8 bits sont plus simples à comprendre sur le plan conceptuel, et les mêmes concepts s'appliquent à des valeurs plus importantes comme l'arithmétique de 32 bits.

Lorsque vous ajoutez deux nombres de 8 bits, vous obtenez le plus grand nombre possible (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, soit deux fois 8 bits.

Maintenant, vous pouvez supposer qu'un processeur x-bit ne peut suivre que des x-bits. (Par exemple, un processeur 8 bits ne peut suivre que 8 bits.) Ce n'est pas exact. 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).)

Donc, lorsque vous donnez à l'ordinateur 3 octets : Octet #1 : l'instruction MUL Octet #2 : les octets d'ordre supérieur (par exemple, 0xA5) Octet #3 : les octets d'ordre inférieur (par exemple, 0xCB) L'ordinateur peut générer un résultat qui est supérieur à 8 bits. L'unité centrale peut générer des résultats comme ceci : 0100 0000 0100 0010 xxxx xxxx xxxx xxxx 1101 0111 alias : 0x4082xxxxD7 Maintenant, laissez-moi interpréter cela pour vous : 0x signifie simplement que les chiffres suivants sont hexadécimaux.
Je parlerai 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, appelés registre “B” et 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 à l'unité centrale) 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 peuvent être altérés, à l'exception de certains des bits de drapeau). D7 rentrerait dans plus de bits, appelés le registre “D”. Un registre est juste un morceau de mémoire. Les registres sont intégrés dans les unités centrales, de sorte que l'unité centrale peut accéder aux registres sans avoir besoin d'interagir avec la mémoire sur une clé USB.

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 ? Eh bien, encore une fois, c'est un exemple de scénario que j'utilise, dont le concept est assez similaire à un vrai langage assembleur (Intel x86 16 bits, tel qu'utilisé par les Intel 8080 et 8088 et de nombreux CPU plus récents). Il pourrait y avoir quelques règles communes, telles que le registre “C” utilisé comme index pour compter les opérations (typique pour les boucles), et le registre “B” utilisé pour garder une trace des décalages qui aident à spécifier les emplacements de mémoire. Ainsi, “A” et “D” peuvent être plus courants pour certaines des fonctions arithmétiques communes.

Chaque instruction du CPU devrait avoir une certaine documentation, utilisée par les personnes qui programment en assembleur. Cette documentation devrait spécifier quels registres sont utilisés par chaque instruction. (Ainsi, le choix des registres à utiliser est souvent spécifié par les concepteurs de l'unité centrale, et non par les programmeurs en langage assembleur. Bien qu'il puisse y avoir une certaine flexibilité).

Maintenant, revenons au “40” dans l'exemple ci-dessus : c'est une série de bits, souvent appelée “registre flags”. Chaque bit du registre des drapeaux a un nom. Par exemple, il y a un bit de “débordement” que le CPU peut définir si le résultat est plus grand que l'espace qui peut stocker un octet des résultats. (Le bit de “débordement” peut souvent être désigné par le nom abrégé “OF”. C'est un “o” majuscule, pas un zéro). Un logiciel peut vérifier la valeur de ce drapeau et noter le “problème”. Le travail avec ce bit est souvent géré de manière invisible par des langages de niveau supérieur, de sorte que les programmeurs débutants n'apprennent souvent pas comment interagir avec les drapeaux du CPU. Cependant, les programmeurs en assembleur peuvent généralement accéder à certains de ces drapeaux d'une 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 de poids faible dans le registre A, ignorer le registre D et spécifier le bit de débordement. Ensuite, plus tard (après avoir stocké les résultats du registre A dans la mémoire vive principale), vous pouvez utiliser une autre instruction ADD qui ne stocke que les 8 bits de poids fort dans un registre (éventuellement le registre A.) La nécessité d'utiliser un drapeau de débordement peut dépendre de l'instruction de multiplication utilisée. La nécessité d'utiliser un indicateur de débordement peut dépendre de l'instruction de multiplication que vous utilisez. (Il y a aussi généralement un indicateur de “sous-débordement”, au cas où vous soustrairez trop de données pour obtenir le résultat souhaité). Juste pour vous montrer à quel point les choses sont devenues compliquées : L'Intel 4004 était un processeur 4 bits L'Intel 8008 était un processeur 8 bits. Il avait des registres de 8 bits nommés A, B, C et D. L'Intel 8086 était un CPU de 16 bits. Il avait des registres de 16 bits nommés AX, BX, CX et DX. L'Intel 80386 était un processeur 32 bits. Il avait 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 un code 16 bits (dans certains modes de fonctionnement) et peuvent interpréter des instructions 16 bits. Ce faisant, les bits qui composent le registre AX sont la moitié des bits qui composent le registre EAX, qui sont la moitié des bits qui composent le registre RAX. Ainsi, chaque fois que vous changez la valeur de AX, vous changez également EAX et RAX, car ces bits utilisés par AX font partie des bits utilisés par RAX. (Si vous changez EAX par une valeur qui est un multiple de 65 536, alors les 16 bits inférieurs sont inchangés, donc AX ne changera pas. Si vous changez EAX par une valeur qui n'est pas un multiple de 65 536, alors cela affectera également AX)

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

Maintenant, si vous êtes sur un CPU 8 bits, lorsque vous écrivez en mémoire, vous pouvez trouver quelques restrictions concernant la possibilité de se référer à une adresse de 8 bits, et non pas à une adresse de 4 bits ou 16 bits. Les détails varieront en fonction du CPU, mais si vous avez de telles restrictions, il se peut que le CPU traite des mots de 8 bits, c'est pourquoi le CPU est le plus souvent appelé “CPU 8 bits”.