¿Cómo se representan los números negativos? -- Signo y magnitud, complemento a uno, complemento a dos

En esta lección entenderás: por qué representar números negativos en una computadora no es tan simple como «poner un signo menos», y cómo el complemento a dos resuelve ingeniosamente todos los problemas.


Analogía cotidiana: la numeración de los pisos de un hotel

Imagina un hotel de 256 pisos.

Si se numeran con números naturales, solo se puede usar del 0 al 255.

Pero, ¿y si queremos incluir desde el «sótano 128» hasta el «piso 127»?

Un truco ingenioso: reinterpretar los números 128~255 como -128~-1.

El número 128 se convierte en -128, el 255 en -1, y el 0 sigue siendo 0.

Esto esla idea central del complemento a dos—dentro de un rango finito de bits, reinterpretar la «segunda mitad» del espacio numérico como números negativos.


La idea más intuitiva: signo y magnitud

La forma más directa de representar negativos: usar el bit más significativo comobit de signo。

  • Bit más significativo 0 = positivo
  • Bit más significativo 1 = negativo
  • Los bits restantes representan el valor absoluto

Tomando 8 bits como ejemplo:

+5 =
0
0
0
0
0
1
0
1
Signo 0 = positivo
-5 =
1
0
0
0
0
1
0
1
Signo 1 = negativo

Parece razonable, ¿verdad? Pero el signo y magnitud tiene dos problemas fatales.

Problema 1: +0 y -0 coexisten

El +0 es00000000, el -0 es10000000。

El mismo valor tiene dos representaciones.

Esto significa que cada vez que se realiza una operación de comparación (para determinar si dos números son iguales), el hardware debe manejar este caso especial adicionalmente.

Problema 2: el sumador no puede hacer restas

Calculando con signo y magnitud5 + (-3):

5 (signo y magnitud)
00000101
+
-3 (signo y magnitud)
10000011
=
Sumar directamente
10001000
=
Resultado
-8

5 + (-3) debería dar 2, pero con signo y magnitud, sumando directamente da -8.

Esto significa que la CPU debe diseñar un circuito de resta por separado, y no puede reutilizar el circuito de suma existente.

Los problemas del signo y magnitud se pueden resumir como: intuitivo pero no práctico. Es adecuado para lectura humana, pero no para implementación en circuitos.


La lección del reloj: aritmética modular

Antes de continuar, necesitamos entender un concepto clave:aritmética modular。

Mira un reloj: la esfera solo tiene 12 marcas.

Partiendo de las 10, si quieres ajustar a las 7, hay dos formas:

Método 1 (sentido antihorario): 10 - 3 =7(resta)

Método 2 (sentido horario): 10 + 9 = 19, 19 mod 12 =7(suma)

En un sistema «módulo 12», -3 y +9 son equivalentes (porque -3 + 12 = 9).

En términos más generales:En un sistema módulo M, restar un número equivale a sumar (M - ese número)。

El complemento a dos aplica esta idea a los números binarios. Para binarios de 8 bits, el módulo es 2^8 = 256.

El complemento a dos de -3 = 256 - 3 = 253 = binario11111101。

Por lo tanto5 + (-3)puede convertirse en5 + 253 = 258。

Pero en un sistema de 8 bits, 258 supera el límite de representación de 255; el acarreo del bit más significativo se «desborda» y se descarta, quedando258 mod 256 = 2。

La suma obtiene el resultado correcto de la resta.


Diagrama circular del complemento a dos (demostración interactiva)

El siguiente diagrama circular muestra intuitivamente el sistema de complemento a dos de 4 bits.

4 bits pueden representar 16 valores (0~15); el complemento a dos los reinterpreta como -8~+7.

Arrastra el control deslizante para cambiar el valor y observa la posición del puntero en el anillo.

Diagrama circular del complemento a dos (sistema de 4 bits, rango -8 ~ +7)

0

Representación binaria:0000| Interpretación sin signo:0

Cargar la librería Plotly.js para dibujar el diagrama circular en coordenadas polares

Diagrama circular del complemento a dos con Plotly (coordenadas polares scatterpolar)

La siguiente figura usa las coordenadas polares de Plotly.js para mostrar las 16 marcas del complemento a dos de 4 bits. Azul = zona positiva, rojo = zona negativa, verde = punto cero.

Zona positiva (0 ~ +7)
Zona negativa (-8 ~ -1)
Punto cero
Punto de desbordamiento (+7→-8)

Significado del anillo:

  • Sentido horario = aumento del valor
  • Dar una vuelta completa (superar el máximo) = volver al punto inicial (efecto de «desbordamiento» de la aritmética modular)
  • Zona roja = negativos (interpretación en complemento a dos), zona azul = positivos
  • El anillo interior indica la interpretación sin signo (correspondiente a 0~15), el anillo exterior indica la interpretación en complemento a dos (-8~+7)

Como se puede ver en la figura,el complemento a dos esencialmente pliega el espacio numérico en un anillo。

Cuando los positivos llegan al final (después de +7), naturalmente se convierten en negativos (-8); la resta y la suma son la misma dirección en el anillo.


Reglas de cálculo del complemento a dos

Para calcular manualmente el complemento a dos de un número, hay dos métodos rápidos equivalentes:

Método 1: método de invertir y sumar 1 (método estándar)

  1. Escribe el binario correspondiente al valor absoluto
  2. Invierte cada bit (0 se convierte en 1, 1 se convierte en 0) para obtener el complemento a uno
  3. Suma 1 al complemento a uno para obtener el complemento a dos

Método 2: método de derecha a izquierda (método de cálculo rápido)

  1. Ve de derecha a izquierda y encuentra el primer 1
  2. Invierte todos los bits a la izquierda de ese 1
  3. El propio 1 y todos los bits a su derecha permanecen sin cambios

Tomando -20 como ejemplo (sistema de 8 bits), verifica con ambos métodos:

Binario de 20
00010100
→
Invertir (complemento a uno)
11101011
→
Sumar 1 (complemento a dos)
11101100

Verificación: el complemento a dos de -20 es 11101100, interpretado sin signo = 236.

236 + 20 = 256, que es exactamente un módulo. Esto demuestra que el cálculo es correcto.


Comparación de las tres representaciones

ValorSigno y magnitudComplemento a unoComplemento a dos
+5000001010000010100000101
-5100001011111101011111011
+0000000000000000000000000
-01000000011111111No existe
+127011111110111111101111111
-127111111111000000010000001
-128No representableNo representable10000000

Observa tres diferencias clave:

  1. El complemento a dos no tiene -0: todos los bits a 1 ya no se desperdician en -0, sino que representan -1.
  2. El complemento a dos tiene un negativo adicional: el rango del complemento a dos de 8 bits es -128 ~ +127, que tiene un -128 adicional en comparación con el rango de -127~+127 del signo y magnitud.
  3. El complemento a dos unifica la suma: sumar positivos y sumar negativos usa el mismo circuito.

Por eso el tipo de Javabytetiene un rango de -128~127, y el de Csigned chartambién es de -128~127. Ambos usan complemento a dos de 8 bits.


Demostración interactiva: calculadora de complemento a dos

Ingresa a continuación un entero dentro del rango de 8 bits (-128 ~ 127) y observa su signo y magnitud, complemento a uno y complemento a dos.

Calculadora de complemento a dos (8 bits)

Ingresa el entero:

Nota especial: al ingresar -128, el complemento a dos es10000000。

El valor absoluto de este número es 128, pero 128 está fuera del rango positivo de 8 bits (0~127).

Por lo tanto, -128 no tiene una representación positiva correspondiente: esta es una característica interesante del sistema de complemento a dos.


Desbordamiento del complemento a dos

El rango del complemento a dos de 8 bits es -128~127.

Si el resultado del cálculo supera este rango, se producedesbordamiento。

127 + 1
-128
(desbordamiento positivo, resultado negativo)
|
-128 - 1
+127
(desbordamiento negativo, resultado positivo)

Esto nuevamente hace eco del diagrama circular anterior: después de llegar al final, los valores «dan la vuelta».

En C/C++, el desbordamiento de enteros con signo escomportamiento indefinido(el compilador puede asumir que no ocurrirá), lo cual es la causa de muchos errores extraños.


Demostración de código: implementación completa del complemento a dos

Ejemplo

# Implementación y verificación completa del complemento a dos (demostración de ejemplo)

def to_twos_complement(n, bits=8):
    """Convierte el entero n a una cadena de complemento a dos de ancho de bits especificado"""
    if n < -2**(bits-1) or n > 2**(bits-1) - 1:
        raise ValueError(f"El valor {n} excede el rango de {bits} bits de complemento a dos [-{2**(bits-1)}, {2**(bits-1)-1}]")

    # Usando aritmética modular: el valor sin signo correspondiente de un negativo n = n + 2^bits
    # En Python, usa directamente la máscara de bits
    mask = (1 << bits) - 1  # Por ejemplo, 8 bits: 0xFF = 255
    unsigned_val = n & mask
    return format(unsigned_val, f'0{bits}b')

def from_twos_complement(bin_str):
    """Convierte la cadena de complemento a dos de vuelta a un entero decimal"""
    bits = len(bin_str)
    unsigned_val = int(bin_str, 2)

    # Si el bit más significativo es 1 (negativo), resta 2^bits
    if bin_str[0] == '1':
        return unsigned_val - (1 << bits)
    else:
        return unsigned_val

def show_conversion_steps(n, bits=8):
    """Muestra los pasos detallados de n a complemento a dos"""
    abs_bin = format(abs(n), f'0{bits}b')
    print(f"Valor: {n}")
    print(f" Paso 1: valor absoluto |{n}| = {abs(n)} → binario = {abs_bin}")

    if n >= 0:
        print(f" Paso 2: el complemento a dos de un número positivo = código original = {abs_bin}")
    else:
        # Invertir
        inverted = ''.join('1' if b == '0' else '0' for b in abs_bin)
        print(f" Paso 2: invertir (complemento a uno) = {inverted}")

        # Sumar 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" Paso 3: complemento a uno + 1 = {result}")

    comp = to_twos_complement(n, bits)
    print(f" → Complemento a dos final: {comp}")

    # Verificación
    recovered = from_twos_complement(comp)
    print(f" Verificación: complemento a dos {comp} → interpretado como {recovered}")
    print()

# Pruebas
print("=" * 50)
print(Demostración de conversión de complemento a dos (sistema de 8 bits))
print("=" * 50)
print()

for val in [5, -5, 0, -1, 127, -128]:
    show_conversion_steps(val)

# Verificar suma con complemento a dos
print("=" * 50)
print(Verificación de suma con complemento a dos: la resta se convierte en suma)
print("=" * 50)

def twos_add(a, b, bits=8):
    """Suma con complemento a dos (incluye manejo de desbordamiento)"""
    mask = (1 << bits) - 1
    result_unsigned = (a + b) & mask
    # Interpretar el resultado con signo
    if result_unsigned >= (1 << (bits - 1)):
        signed_result = result_unsigned - (1 << bits)
    else:
        signed_result = result_unsigned
    return signed_result

# 5 - 3 = 2
print(f"5 + (-3) = {twos_add(5, -3)} (esperado: 2)")

# 127 + 1 = -128 (desbordamiento)
print(f"127 + 1 = {twos_add(127, 1)} (esperado: -128, se produjo desbordamiento)")

# -128 - 1 = 127 (desbordamiento)
print(f"-128 + (-1) = {twos_add(-128, -1)} (esperado: 127, se produjo desbordamiento)")

# Suma de ceros
print(f"0 + 0 = {twos_add(0, 0)} (esperado: 0)")

# Verificar con el carácter EJEMPLO: R=82, U=85 → 82 + (-85) = -3
print(f"\nPrueba EJEMPLO: R(82) + (-U(85)) = {twos_add(82, -85)} (esperado: -3)")

# Mostrar la propiedad cíclica del complemento a dos
print("\nAnillo de complemento a dos (versión simplificada de 4 bits, rango -8~+7):")
print(Valor | Complemento | Sin signo)
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}")
Otras extensiones