Comment les nombres négatifs sont-ils représentés -- signe-magnitude, complément à un, complément à deux
Dans ce cours, vous comprendrez : pourquoi représenter les nombres négatifs dans les ordinateurs n'est pas aussi simple que « ajouter un signe moins », et comment le complément à deux résout astucieusement tous les problèmes.
Analogie inspirée de la vie réelle : numérotation des étages d'un hôtel
Imaginez un hôtel de 256 étages.
Si on les numérote avec des nombres naturels, on ne peut utiliser que 0 à 255.
Mais que se passe-t-il si nous voulons numéroter de « 128 étages en sous-sol » à « 127 étages au-dessus du sol » ?
Une approche astucieuse : réinterpréter les nombres 128~255 comme -128~-1.
Le nombre 128 devient -128, le nombre 255 devient -1, et le nombre 0 reste 0.
Ceci estl'idée centrale du complément à deux— Dans un intervalle fini de bits, réinterpréter la « seconde moitié » de l'espace des valeurs comme des nombres négatifs.
L'idée la plus simple : signe-magnitude (code original)
L'idée la plus directe pour représenter les nombres négatifs : utiliser le bit de poids fort commeBit de signe。
- Bit de poids fort 0 = nombre positif
- Bit de poids fort 1 = nombre négatif
- Les bits restants représentent la valeur absolue
Prenons 8 bits comme exemple :
Cela semble raisonnable, non ? Mais la représentation signe-magnitude a deux problèmes fatals.
Premier problème : +0 et -0 existent tous les deux.
Le 0 positif est00000000, le 0 négatif est10000000。
La même valeur possède deux représentations.
Cela signifie que chaque opération de comparaison (vérifier si deux nombres sont égaux) oblige le matériel à gérer en plus ce cas particulier.
Problème 2 : l'additionneur ne peut pas effectuer de soustraction
Calculer en signe-magnitude5 + (-3):
5 + (-3) devrait être égal à 2, mais l'addition directe en signe-magnitude donne -8.
Cela signifie que le CPU doit concevoir séparément un circuit de soustraction au lieu de réutiliser le circuit d'addition existant.
Le problème de la représentation signe-magnitude peut se résumer ainsi : intuitive mais peu pratique. Elle convient à la lecture par des humains, mais pas à l'implémentation de circuits.
La révélation de l'horloge : l'arithmétique modulaire
Avant de continuer, nous devons comprendre un concept clé—opération modulo。
Regardez une horloge : le cadran ne comporte que 12 graduations.
En partant de 10 heures, vous voulez passer à 7 heures. Il y a deux façons :
Première méthode (dans le sens antihoraire) : 10 - 3 =7(Soustraction)
Méthode 2 (dans le sens horaire) : 10 + 9 = 19, 19 mod 12 =7(Addition)
Dans un système "modulo 12", -3 et +9 sont équivalents (car -3 + 12 = 9).
Plus généralement :Dans un système modulo M, soustraire un nombre équivaut à ajouter (M - ce nombre)。
Le complément à deux applique cette idée au binaire. Pour le binaire 8 bits, le module est 2^8 = 256.
Le complément à deux de -3 = 256 - 3 = 253 = binaire.11111101。
therefore5 + (-3)Peut devenir5 + 253 = 258。
Mais dans un système 8 bits, 258 dépasse la limite supérieure de 255. La retenue du bit le plus élevé "déborde" et est rejetée, laissant258 mod 256 = 2。
L'addition a donné le résultat correct de la soustraction.
Schéma en anneau du complément à deux (démo interactive)
Le diagramme en anneau ci-dessous montre intuitivement un système de complément à deux sur 4 bits.
4 bits peuvent représenter 16 valeurs (0~15) ; le complément à deux les réinterprète comme -8~+7.
Faites glisser le curseur pour changer la valeur et observez la position du pointeur sur l'anneau.
Diagramme en anneau du complément à deux (système 4 bits, plage -8 ~ +7)
Représentation binaire :0000| Interprétation non signée :0
Diagramme en anneau du complément à deux avec Plotly (coordonnées polaires scatterpolar).
La figure ci-dessous utilise les coordonnées polaires de Plotly.js pour afficher les 16 graduations du complément à deux sur 4 bits. Bleu = région positive, rouge = région négative, vert = point zéro.
Signification du caractère cyclique :
- Sens horaire = la valeur augmente
- Faire un tour complet (dépasser le maximum) = revenir au point de départ (l’effet « débordement » de l’arithmétique modulaire)
- Région rouge = nombres négatifs (interprétation en complément à deux), région bleue = nombres positifs
- L’anneau intérieur est étiqueté avec l’interprétation non signée (correspondant à 0~15), l’anneau extérieur est étiqueté avec l’interprétation en complément à deux (-8~+7)
D’après le diagramme, on peut voir que,Le complément à deux replie essentiellement l’espace des valeurs en un anneau.。
Lorsque les nombres positifs atteignent la fin (après +7), ils deviennent naturellement négatifs (-8). La soustraction et l’addition se font dans le même sens sur l’anneau.
Règles de calcul du complément à deux
Pour calculer manuellement le complément à deux d’un nombre, il existe deux méthodes rapides équivalentes :
Première méthode : inverser et ajouter 1 (méthode standard)
- Écrire le code binaire correspondant à la valeur absolue
- Inverser chaque bit (0 devient 1, 1 devient 0) pour obtenir le complément à un
- Ajouter 1 au complément à un pour obtenir le complément à deux
Méthode deux : de droite à gauche (méthode de calcul rapide)
- Trouver le premier 1 de droite à gauche
- Inverser tous les bits à gauche de ce 1
- Ce 1 et tous les bits à sa droite restent inchangés
Prenons -20 comme exemple (système 8 bits), vérifier avec les deux méthodes :
Vérification : le complément à deux de -20 est 11101100 ; interprété comme non signé, il vaut 236.
236 + 20 = 256, exactement un module. Cela montre que le calcul est correct.
Comparaison des trois représentations
| value | signe et valeur absolue | complément à 1 | complément à 2 |
|---|---|---|---|
| +5 | 00000101 | 00000101 | 00000101 |
| -5 | 10000101 | 11111010 | 11111011 |
| +0 | 00000000 | 00000000 | 00000000 |
| -0 | 10000000 | 11111111 | N'existe pas |
| +127 | 01111111 | 01111111 | 01111111 |
| -127 | 11111111 | 10000000 | 10000001 |
| -128 | Ne peut pas représenter | Ne peut pas représenter | 10000000 |
Notez trois différences clés :
- Le complément à 2 n'a pas de -0: tous les 1 ne sont plus gaspillés pour -0, mais représentent à la place -1.
- Le complément à 2 a un nombre négatif en plusLa plage du complément à 2 sur 8 bits est -128 ~ +127, ce qui fait un -128 de plus que la plage en signe et valeur absolue de -127 ~ +127.
- Le complément à 2 unifie l'addition: l'addition de nombres positifs et négatifs utilise le même circuit.
C'est pourquoi, en Java,
byteLa plage du type est -128~127, et celle du langage Csigned charest aussi -128~127. Ils utilisent tous deux le complément à deux sur 8 bits.
Démo interactive : calculateur de complément à deux
Ci-dessous, saisissez un entier dans la plage sur 8 bits (-128 ~ 127) pour afficher sa représentation signe-magnitude, son complément à un et son complément à deux.
Calculateur de complément à deux (8 bits)
Remarque spéciale : lorsque -128 est saisi, le complément à deux est10000000。
La valeur absolue de ce nombre est 128, mais 128 est en dehors de la plage positive sur 8 bits (0~127).
Ainsi, -128 n'a pas de représentation positive correspondante — c'est une propriété intéressante du système de complément à deux.
Débordement en complément à deux
La plage du complément à deux sur 8 bits est -128~127.
Si le résultat du calcul dépasse cette plage, cela provoqueraun débordement。
Cela fait à nouveau écho au diagramme en anneau précédent—après avoir atteint la fin, la valeur "revient au début".
En C/C++, le dépassement des entiers signés estun comportement indéfini(le compilateur peut supposer qu'il ne se produit jamais), ce qui est la source de nombreux bogues étranges.
Démo de code : implémentation complète du complément à deux
Exemple
def to_twos_complement(n, bits=8):
Convertir l'entier n en une chaîne en complément à deux avec la largeur de bits spécifiée
if n < -2**(bits-1) or n > 2**(bits-1) - 1:
raise ValueError(fLa valeur {n} est en dehors de la plage du complément à deux sur {bits} bits [-{2**(bits-1)}, {2**(bits-1)-1}])
# Utilisation de l'arithmétique modulo : l'équivalent non signé d'un nombre négatif n = n + 2^bits
# Utilisation directe d'un masque de bits en Python
mask = (1 << bits) - 1 # Par exemple, 8 bits : 0xFF = 255
unsigned_val = n & mask
return format(unsigned_val, f'0{bits}b')
def from_twos_complement(bin_str):
"""Convertit une chaîne en complément à deux en un entier décimal."""
bits = len(bin_str)
unsigned_val = int(bin_str, 2)
# Si le bit de poids fort est 1 (négatif), soustraire 2^bits
if bin_str[0] == '1':
return unsigned_val - (1 << bits)
else:
return unsigned_val
def show_conversion_steps(n, bits=8):
"""Afficher les étapes détaillées de n au complément à deux."""
abs_bin = format(abs(n), f'0{bits}b')
print(f"Valeur : {n}")
print(fÉtape 1 : valeur absolue |{n}| = {abs(n)} → binaire = {abs_bin})
if n >= 0:
print(f" Étape 2 : le complément à deux d'un nombre positif = signe-magnitude = {abs_bin}")
else:
# Inverser
inverted = ''.join('1' if b == '0' else '0' for b in abs_bin)
print(fÉtape 2 : Inverser (complément à un) = {inverted})
# ajouter 1
carry = 1
result_list = list(inverted)
for i in range(bits - 1, -1, -1):
if carry == 0:
break
total = int(result_list[i]) + carry
result_list[i] = str(total % 2)
carry = total // 2
result = ''.join(result_list)
print(fÉtape 3 : complément à un + 1 = {result})
comp = to_twos_complement(n, bits)
print(f" → Complément à deux final : {comp}")
# Vérifier
recovered = from_twos_complement(comp)
print(fVérification : complément à deux {comp} → interprété comme {recovered})
print()
# Test
print("=" * 50)
print("Démo de conversion en complément à deux (système 8 bits)")
print("=" * 50)
print()
for val in [5, -5, 0, -1, 127, -128]:
show_conversion_steps(val)
# Vérifier l'addition en complément à deux
print("=" * 50)
print("Vérification de l'addition en complément à deux : la soustraction devient une addition")
print("=" * 50)
def twos_add(a, b, bits=8):
"""Addition en complément à deux (y compris la gestion du débordement)"""
mask = (1 << bits) - 1
result_unsigned = (a + b) & mask
# Interpréter le résultat signé
if result_unsigned >= (1 << (bits - 1)):
signed_result = result_unsigned - (1 << bits)
else:
signed_result = result_unsigned
return signed_result
# 5 - 3 = 2
print(f5 + (-3) = {twos_add(5, -3)} (attendu : 2))
# 127 + 1 = -128 (débordement)
print(f127 + 1 = {twos_add(127, 1)} (attendu : -128, débordement survenu))
# -128 - 1 = 127 (débordement)
print(f-128 + (-1) = {twos_add(-128, -1)} (attendu : 127, débordement survenu))
# ajouter zéro
print(f0 + 0 = {twos_add(0, 0)} (attendu : 0))
# Vérifier avec les caractères EXEMPLE : R=82, U=85 → 82 + (-85) = -3
print(f"\nTest EXEMPLE : R(82) + (-U(85)) = {twos_add(82, -85)} (attendu : -3)")
# Démonstration de la nature cyclique du complément à deux
print("\nAnneau du complément à deux (version simplifiée sur 4 bits, plage -8 à +7) :)
print("Valeur | Complément à deux | Non signé")
print("-" * 30)
for n in range(-8, 8):
comp = to_twos_complement(n, 4)
unsig = int(comp, 2)
print(f" {n:3d} | {comp} | {unsig:2d}")