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 :

+5 =
0
0
0
0
0
1
0
1
Bit de signe 0 = positif
-5 =
1
0
0
0
0
1
0
1
Bit de signe 1 = négatif

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 (signe-magnitude)
00000101
+
-3 (signe-magnitude)
10000011
=
Additionner directement
10001000
=
Résultat
-8

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)

0

Représentation binaire :0000| Interprétation non signée :0

Chargez la bibliothèque Plotly.js pour dessiner un diagramme en anneau polaire

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.

Plage positive (0 à +7)
Région des nombres négatifs (-8 à -1)
point zéro
Point de débordement (+7→-8)

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)

  1. Écrire le code binaire correspondant à la valeur absolue
  2. Inverser chaque bit (0 devient 1, 1 devient 0) pour obtenir le complément à un
  3. Ajouter 1 au complément à un pour obtenir le complément à deux

Méthode deux : de droite à gauche (méthode de calcul rapide)

  1. Trouver le premier 1 de droite à gauche
  2. Inverser tous les bits à gauche de ce 1
  3. 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 :

20 en binaire
00010100
→
Inverser (complément à un)
11101011
→
Ajouter 1 (complément à deux)
11101100

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

valuesigne et valeur absoluecomplément à 1complément à 2
+5000001010000010100000101
-5100001011111101011111011
+0000000000000000000000000
-01000000011111111N'existe pas
+127011111110111111101111111
-127111111111000000010000001
-128Ne peut pas représenterNe peut pas représenter10000000

Notez trois différences clés :

  1. 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.
  2. 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.
  3. 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)

Entier à saisir :

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。

127 + 1
-128
(Débordement positif, résultat négatif)
|
-128 - 1
+127
(Débordement négatif, résultat positif)

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

# Implémentation complète et vérification du complément à deux (démo d'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}")
autres extensions