Supondo números binários de 8 bits com sinal, realize as seguintes adições e indique se ocorreu overflow:
10001100_{2}+00111001_{2}

Passo 1

O enunciado pede que se realize a adição, em aritmética de números binários de 8 bits com sinal, de
10001100_2 + 00111001_2,
e que se indique se ocorreu overflow. Os dados fornecidos são exatamente esses dois bytes (8 bits cada).

Passo 2

Primeiro vamos lembrar (de forma didática) como interpretar e somar números binários de 8 bits com sinal no esquema mais usado: complemento de dois. Regras-chave (explicadas passo a passo):
  • Em complemento de dois, o bit mais à esquerda ( b_7) é o bit de sinal: se b_7=0 o número é não-negativo; se b_7=1 o número é negativo.
  • O valor numérico de um byte (b_7 b_6 \dots b_0) em complemento de dois pode ser obtido por:
\text{valor} = -b_7\cdot 2^{7} + \sum_{i=0}^{6} b_i\cdot 2^{i}.
  • Alternativamente, para obter o valor decimal de um número negativo (quando b_7=1), pode-se inverter todos os bits e somar 1 para achar a magnitude, e então pôr sinal negativo.
  • Regra prática para detectar overflow em complemento de dois: overflow ocorre se, ao somar, os dois operandos têm o mesmo sinal e o resultado tiver sinal diferente. Outra forma equivalente é checar o XOR entre o carry para o bit de sinal e o carry de saída do bit de sinal: se forem diferentes, houve overflow.

Passo 3

Vamos converter cada operando para decimal (para entender o que esperamos do resultado).
Para \,10001100_2: usar a fórmula direta dá
-1\cdot2^{7} + 0\cdot2^{6} + 0\cdot2^{5} + 0\cdot2^{4} + 1\cdot2^{3} + 1\cdot2^{2} + 0\cdot2^{1} + 0\cdot2^{0}
= -128 + 8 + 4 = -116.
Verificação alternativa (inverter + 1): inverter 10001100_2 01110011_2; somar 1 01110100_2. 01110100_2 é 64+32+16+4=116, então o número é -116. Tudo coerente.

Passo 4

Para \,00111001_2 o bit de sinal é 0, então é positivo. Converter:
00111001_2 = 0\cdot128 + 0\cdot64 + 1\cdot32 + 1\cdot16 + 1\cdot8 + 0\cdot4 + 0\cdot2 + 1\cdot1
= 32 + 16 + 8 + 1 = 57.

Passo 5

Em decimal, a soma deve dar
-116 + 57 = -59.
Isso nos dá um referencial: o resultado esperado em complemento de dois deve ser o valor binário que representa -59.

Passo 6

Agora fazemos a adição bit a bit (para quem prefere ver a operação binária explícita). Somando os bits da direita para a esquerda, anotando os carries:
\begin{array}{r} \;10001100\\\\ +\,00111001\\\ \hline \;11000101 \end{array}
Para ficar bem claro, descrevo cada coluna (bit menos significativo para mais significativo), com o carry entrando na coluna:
  • bit 0: 0+1=1, carry 0.
  • bit 1: 0+0+0=0, carry 0.
  • bit 2: 1+0+0=1, carry 0.
  • bit 3: 1+1+0=0, carry 1.
  • bit 4: 0+1+1(\text{carry})=0, carry 1.
  • bit 5: 0+1+1(\text{carry})=0, carry 1.
  • bit 6: 0+0+1(\text{carry})=1, carry 0.
  • bit 7 (sinal): 1+0+0(\text{carry})=1, carry de saída 0.
Resultado binário obtido: \,11000101_2.

Passo 7

Interpretando o resultado \,11000101_2 como complemento de dois (8 bits): o bit de sinal é 1, então é negativo. Convertemos para decimal para confirmar que bate com o valor esperado -59.
Inverter 11000101_2 00111010_2. Somar 1 00111011_2.
00111011_2 = 32 + 16 + 8 + 2 + 1 = 59,
logo o número é -59. Isso coincide com o que esperávamos de -116 + 57.

Passo 8

Verificação de overflow (explicando a ideia para você saber usar na prova):
  • Como regra rápida: se os operandos têm sinais diferentes (um positivo e outro negativo), a soma NÃO pode causar overflow em complemento de dois. Aqui os operandos eram -116 (sinal 1) e +57 (sinal 0) — sinais diferentes — portanto não houve overflow.
  • Conferindo pela regra dos carries: o carry para o bit de sinal (entrada na coluna do bit 7) foi 0 e o carry de saída do bit de sinal foi 0; o XOR entre esses carries é 0, então não houve overflow. Ambas as checagens confirmam: sem overflow.

Resposta

10001100_2 + 00111001_2 = 11000101_2 = -59
Sem overflow

Exercícios relacionados