¿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:
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 + (-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)
Representación binaria:0000| Interpretación sin signo:0
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.
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)
- Escribe el binario correspondiente al valor absoluto
- Invierte cada bit (0 se convierte en 1, 1 se convierte en 0) para obtener el complemento a uno
- 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)
- Ve de derecha a izquierda y encuentra el primer 1
- Invierte todos los bits a la izquierda de ese 1
- 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:
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
| Valor | Signo y magnitud | Complemento a uno | Complemento a dos |
|---|---|---|---|
| +5 | 00000101 | 00000101 | 00000101 |
| -5 | 10000101 | 11111010 | 11111011 |
| +0 | 00000000 | 00000000 | 00000000 |
| -0 | 10000000 | 11111111 | No existe |
| +127 | 01111111 | 01111111 | 01111111 |
| -127 | 11111111 | 10000000 | 10000001 |
| -128 | No representable | No representable | 10000000 |
Observa tres diferencias clave:
- El complemento a dos no tiene -0: todos los bits a 1 ya no se desperdician en -0, sino que representan -1.
- 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.
- El complemento a dos unifica la suma: sumar positivos y sumar negativos usa el mismo circuito.
Por eso el tipo de Java
bytetiene 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)
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。
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
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}")