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

Vous avez raison de dire qu'un entier de 32 bits ne peut pas contenir 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 assemblés dans un format qui a du sens pour vous, l'être humain.

Un concept connexe en programmation est typage qui est la façon dont un ordinateur interprète un flux particulier de données. 0 et 1 s. Comme dans l'exemple ci-dessus, il peut être interprété comme une valeur numérique, un caractère, ou même quelque chose d'entièrement différent. Si un nombre 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 totalement différente.

En ce qui concerne la façon dont les ordinateurs peuvent travailler avec et traiter les grands nombres en interne, il existe des nombres 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.

Tout d'abord, les ordinateurs 32 bits peuvent stocker des nombres allant jusqu'à 2 32 -1 dans un seul mot machine . Mot de la machine est la quantité de données que le CPU 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 les plus rapides à réaliser). Les CPU 32 bits utilisent des mots composés de 32 bits, ils peuvent donc stocker des nombres de 0 à 2. 32 -1 en un mot .

Deuxièmement, 1 trillion y 1000000000000 sont deux choses différentes.

• 1 trillion est un concept abstrait d'un nombre
• 1000000000000 est un texte

En appuyant sur 1 une fois et ensuite 0 12 fois que vous tapez du texte. 1 entrées 1 , 0 entrées 0 . Tu vois ? Tu tapes des caractères. Les caractères ne sont pas des nombres. Les machines à écrire n'avaient ni unité centrale ni mémoire et elles géraient ces "nombres" plutôt bien, car ce n'est que du texte.

Preuve que 1000000000000 n'est pas un numéro, 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. Signification de 1000000000000 est un nombre et stocker ce nombre est une autre histoire (nous y reviendrons dans un instant).

Pour stocker le texte (en programmation, on appelle cela un chaîne de caractères ) 1000000000000 vous avez besoin de 14 octets (un pour chaque caractère plus un octet NULL de fin qui signifie essentiellement "la chaîne se termine ici"). Cela représente 4 mots machine. 3 et demi seraient suffisants, mais comme je l'ai dit, les opérations sur les mots machine sont les plus rapides. Supposons que ASCII est utilisé pour l'encodage du texte, donc en mémoire il ressemblera à ceci : (en convertissant les codes ASCII correspondant à 0 y 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 tiennent dans un mot, le reste est déplacé dans le mot suivant. Le reste est déplacé vers le mot suivant jusqu'à ce que tout (y compris le premier octet NULL) tienne.

Maintenant, revenons au stockage des chiffres. Cela fonctionne de la même manière que pour le texte débordant, mais ils sont placés de droite à gauche. Cela peut sembler compliqué, alors voici un exemple. Pour des raisons 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 un souvenir vide de 2 mots :

0 0
0 0

Stockons le numéro 4 :

0 4
0 0

Maintenant, ajoutons 9 :

1 3
0 0

Remarquez que les deux opérandes tiennent dans un octet, mais pas le résultat. Mais nous en avons un autre prêt à être utilisé. Maintenant, nous allons stocker 99 :

9 9
0 0

Encore une fois, nous avons utilisé le deuxième octet pour stocker le nombre. Ajoutons 1 :

0 0
0 0

Oups... Cela s'appelle dépassement d'un nombre entier et est une cause de nombreux problèmes graves, parfois très chers .

Mais si nous nous attendons à ce qu'un 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 retours à la ligne séparant les octets :

0099    | +1
0100

Nous avons prévu qu'un débordement pourrait se produire et que nous aurions besoin de mémoire supplémentaire. La manipulation des nombres de cette manière n'est pas aussi rapide que celle des nombres qui tiennent dans un seul mot et elle doit être implémentée dans un logiciel. L'ajout de la prise en charge des nombres de deux mots de 32 bits à un processeur de 32 bits en fait un processeur de 64 bits (il peut maintenant fonctionner sur des nombres de 64 bits en mode natif, n'est-ce pas ?)

Tout ce que j'ai décrit ci-dessus s'applique aussi à 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 ces nombres en système décimal est cependant délicate. (mais il fonctionne très bien avec l'hexadécimal )

Vous êtes également en mesure d'écrire "CETTE DÉCLARATION EST FAUSSE" sans que votre ordinateur ne tombe en panne :) La réponse de @Scott est juste pour certains cadres de calcul, mais votre question sur "l'écriture" d'un grand nombre implique que c'est juste du texte brut, au moins jusqu'à ce qu'il soit interprété.

編集する。 maintenant avec moins de sarcasme plus d'informations utiles sur les différentes façons dont un numéro peuvent être stockés en mémoire. Je les décrirai avec abstraction supérieure 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 sur un ordinateur doivent être restreintes à un certain type Une définition informatique de ce type de données décrit les opérations qui peuvent être effectuées sur ces données et la manière dont elles peuvent l'être (par exemple, comparer des nombres, concaténer du texte ou combiner 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 ; certaines de ces valeurs peuvent donc être converties entre les types.

Commençons par entiers non signés . Dans ces types de valeurs, tous les bits sont utilisés pour stocker des informations sur les chiffres. Nombre entier non signé de 32 bits où toute valeur de 0 a 2^32-1 peuvent être stockées. Et oui, selon le langage ou l'architecture de la plate-forme utilisée, vous pouvez avoir des entiers de 16 bits ou des entiers de 256 bits.

Et si tu veux être négatif ? Intuitivement, nombres entiers signés est le nom du jeu. La convention est d'allouer toutes les valeurs de -2^(n-1) a 2^(n-1)-1 - de cette façon, nous évitons la confusion d'avoir à gérer deux façons d'écrire +0 y -0 . Ainsi, un nombre entier signé de 32 bits peut contenir une valeur comprise entre -2147483648 a 2147483647 . Neat, n'est-ce pas ?

Ok, nous avons couvert les nombres entiers qui sont des nombres sans composante décimale. L'expression de ces nombres est plus délicate : la partie non entière ne peut raisonnablement être que quelque part entre 0 y 1 Ainsi, chaque bit supplémentaire utilisé pour le décrire augmente sa précision : 1/2, 1/4, 1/8... Le problème est que l'on ne peut 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 simple de stocker le nombre comme un entier, mais de convenir de mettre le point radix (décimal) à la place ? C'est ce qu'on appelle point fixe où nous stockons 1234100 mais s'accordent sur une convention pour le lire comme 1234.100 à la place.

Un type relativement plus courant utilisé pour les calculs est floating point . La façon dont il fonctionne est très intéressante, il utilise un bit pour stocker la valeur du signe, puis d'autres pour stocker l'exposant et le significande. Il existe des normes qui définissent de telles allocations, mais pour une Flottant 32 bits le nombre maximum que vous pourriez stocker est une énorme perte de temps.

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

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

javascript:alert(0.1+0.2);

Il existe d'autres types d'alternatives, comme l'option de Microsoft .NET 4.5. BigInteger qui n'a théoriquement pas de limites supérieures ou inférieures et doit être calculé par "lots" ; mais les technologies les plus fascinantes sont peut-être celles qui comprendre les mathématiques, comme le moteur Wolfram Mathematica, qui peut précisément travailler avec des valeurs abstraites comme infinité .

La clé est de comprendre comment les ordinateurs encoder numéros.

Il est vrai que 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), alors un ordinateur 32 bits ne peut stocker que des nombres jusqu'à 2^32. Mais il y a beaucoup d'autres façons de coder les nombres en fonction de ce que vous voulez obtenir avec eux.

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

Mais il existe de nombreuses autres options si vous avez besoin d'une précision supplémentaire. Il est évident que vous pouvez utiliser un plus grand nombre de mots dans votre encodage sans limite (mais avec une pénalité de performance pour convertir vers et depuis le format encodé). Si vous voulez explorer une façon de faire, il existe un excellent complément open-source pour Excel qui utilise un schéma d'encodage permettant des centaines de chiffres de précision dans les calculs. Ce complément s'appelle Xnumbers et est disponible à l'adresse suivante aquí . 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.