O que a Calculadora Hexadecimal faz
A Calculadora Hexadecimal realiza operações aritméticas diretamente com números hexadecimais (base 16). Em vez de converter para decimal manualmente, fazer a conta e converter de volta, você só precisa digitar dois valores hexadecimais, escolher uma operação e obter a resposta em hexadecimal. Ela oferece adição, subtração, multiplicação e divisão, o que é útil para programadores, engenheiros de sistemas embarcados e qualquer pessoa que trabalhe com endereços de memória, códigos de cores ou dados em nível de byte.
Os campos de entrada
- Valor hexadecimal 1: seu primeiro número hexadecimal (dígitos 0–9 e letras A–F).
- Operação: escolha Somar, Subtrair, Multiplicar ou Dividir.
- Valor hexadecimal 2: seu segundo número hexadecimal.
Como o cálculo funciona
Nos bastidores, as duas sequências hexadecimais são convertidas em números inteiros (de base 16 para base 10). A operação escolhida é aplicada e, depois, o resultado é convertido de volta para hexadecimal em maiúsculas. Em termos de fórmula:
- Somar: \( \text{Resultado}_{16} = \text{Hex}_1 + \text{Hex}_2 \)
- Subtrair: \( \text{Resultado}_{16} = \text{Hex}_1 - \text{Hex}_2 \)
- Multiplicar: \( \text{Resultado}_{16} = \text{Hex}_1 \times \text{Hex}_2 \)
- Dividir: \( \text{Resultado}_{16} = \left\lfloor \frac{\text{Hex}_1}{\text{Hex}_2} \right\rfloor \) (divisão inteira, o resto é descartado)
Como o cálculo usa aritmética de inteiros de precisão arbitrária, ele lida com valores hexadecimais muito grandes sem estouro (overflow). Se você dividir por zero (Valor hexadecimal 2 = 0), a calculadora retorna "Error", pois a divisão por zero é indefinida.
Exemplo prático
Suponha que você digite Valor hexadecimal 1 = 1A, escolha Multiplicar e digite Valor hexadecimal 2 = F.
- 1A em decimal = 26
- F em decimal = 15
- \( 26 \times 15 = 390 \)
- 390 de volta em hexadecimal = 186
Então $$ 1A \times F = 186 $$ em hexadecimal. A calculadora mostra o resultado em hexadecimal e também os valores decimais correspondentes, para você conferir.
Tabela de conversão entre hexadecimal, decimal e binário
O hexadecimal é um sistema de numeração de base 16: ele usa os dez dígitos 0–9 mais as seis letras A–F para representar os valores de dez a quinze. Como \(16 = 2^4\), cada dígito hexadecimal corresponde exatamente a quatro bits (um nibble), e por isso o hexadecimal é a forma abreviada padrão para dados binários na computação em todo o mundo.
| Hex | Decimal | Binário (4 bits) |
|---|---|---|
| 0 | 0 | 0000 |
| 1 | 1 | 0001 |
| 2 | 2 | 0010 |
| 3 | 3 | 0011 |
| 4 | 4 | 0100 |
| 5 | 5 | 0101 |
| 6 | 6 | 0110 |
| 7 | 7 | 0111 |
| 8 | 8 | 1000 |
| 9 | 9 | 1001 |
| A | 10 | 1010 |
| B | 11 | 1011 |
| C | 12 | 1100 |
| D | 13 | 1101 |
| E | 14 | 1110 |
| F | 15 | 1111 |
Os valores posicionais crescem por um fator de 16 da direita para a esquerda, exatamente como as casas decimais crescem por 10:
| Posição (da direita) | Potência | Valor decimal |
|---|---|---|
| 1ª | \(16^0\) | 1 |
| 2ª | \(16^1\) | 16 |
| 3ª | \(16^2\) | 256 |
| 4ª | \(16^3\) | 4096 |
| 5ª | \(16^4\) | 65536 |
Assim, um número hexadecimal de quatro dígitos é lido como
$$N = d_3 \times 16^3 + d_2 \times 16^2 + d_1 \times 16 + d_0$$Os valores de referência a seguir aparecem o tempo todo em programação, mapas de memória e formatos de arquivo:
| Hex | Decimal | Binário | Significado |
|---|---|---|---|
| 0xFF | 255 | 11111111 | Maior valor sem sinal de 8 bits (1 byte) |
| 0x100 | 256 | 1 0000 0000 | Um a mais que um byte completo; 28 |
| 0x3E8 | 1000 | 11 1110 1000 | Mil em decimal |
| 0xFFFF | 65535 | dezesseis 1s | Maior valor sem sinal de 16 bits (2 bytes) |
| 0x10000 | 65536 | 1 seguido de dezesseis 0s | 216; um bloco de 64 KiB |
| 0xFFFFFFFF | 4294967295 | trinta e dois 1s | Maior valor sem sinal de 32 bits (4 bytes) |
Observe o padrão: \(n\) dígitos hexadecimais F equivalem a \(16^n - 1\), e cada dígito hexadecimal adicional multiplica o intervalo por 16 (acrescenta 4 bits).
Como fazer aritmética hexadecimal à mão
Toda operação hexadecimal segue o mesmo esqueleto: verificar os dígitos, trabalhar numa base com a qual você se sinta à vontade e, por fim, apresentar a resposta de volta em base 16. Os passos abaixo correspondem ao que a calculadora faz internamente.
- Valide os dígitos. Cada caractere deve ser 0–9 ou A–F (maiúsculas ou minúsculas não importam; a = A = 10). Qualquer outro caractere — G, um espaço no meio, uma vírgula perdida — torna o valor inválido. Um prefixo
0xno início ou umhno final é apenas notação e é removido antes do cálculo. - Expanda cada dígito pela sua potência de 16 para obter um valor decimal fácil de raciocinar. Por exemplo:
\(2F_{16} = 2 \times 16 + 15 = 32 + 15 = 47_{10}\)
\(1A7_{16} = 1 \times 256 + 10 \times 16 + 7 = 256 + 160 + 7 = 423_{10}\) - Some ou subtraia coluna por coluna, da direita para a esquerda. Se preferir, trabalhe direto em hexadecimal: quando o total de uma coluna chegar a 16 ou mais, escreva o total menos 16 e passe 1 para a coluna seguinte; ao subtrair, se o dígito de cima for menor, peça emprestado da coluna à esquerda — esse empréstimo vale 16, não 10.
- Para multiplicação e divisão, converta para decimal, calcule e converta de volta. A multiplicação longa em base 16 exige uma tabuada de 16×16, então converter é mais rápido e bem menos sujeito a erros quando se faz à mão. Esta calculadora faz divisão inteira (com truncamento): o quociente é truncado em direção a zero e o resto é descartado, e dividir por \(0_{16}\) é indefinido.
- Converta a resposta decimal de volta para hexadecimal por divisões sucessivas por 16, lendo os restos de baixo para cima. Para 390:
\(390 \div 16 = 24\) resto \(6\)
\(24 \div 16 = 1\) resto \(8\)
\(1 \div 16 = 0\) resto \(1\)
Lendo os restos de baixo para cima, obtém-se \(186_{16}\). Verificação: \(1 \times 256 + 8 \times 16 + 6 = 390\). Restos de 10–15 são escritos como A–F.
Exemplo prático: adição
Some \(2F_{16} + 1A7_{16}\).
- Coluna mais à direita: \(F + 7 = 15 + 7 = 22\). Como \(22 \ge 16\), escreva \(22 - 16 = 6\) e passe 1 para a próxima coluna.
- Coluna do meio: \(2 + A + 1_{\text{vai um}} = 2 + 10 + 1 = 13 = D\), sem transporte.
- Coluna da esquerda: resta apenas o \(1\), que desce diretamente.
O resultado é 1D616. Verificação em decimal: \(47 + 423 = 470\), e \(1 \times 256 + 13 \times 16 + 6 = 256 + 208 + 6 = 470\). ✓
Exemplo prático: subtração com empréstimo
Calcule \(200_{16} - 1A_{16}\). Em decimal, isso é \(512 - 26 = 486\). Dígito por dígito: \(0 - A\) exige um empréstimo e, como o dígito vizinho também é 0, o empréstimo vem em cascata a partir do 2 inicial, resultando nas colunas \(1, F, 16-10=6\) → \(1E6_{16}\). Verificação: \(256 + 14 \times 16 + 6 = 256 + 224 + 6 = 486\). ✓
Exemplo prático: divisão com truncamento
Divida \(FF_{16} \div 10_{16}\). Convertendo: \(255 \div 16 = 15{,}9375\). A divisão inteira trunca para 15, e \(15_{10} = F_{16}\), então a resposta é F16 — o resto de 15 é descartado. Um atalho útil: dividir por \(10_{16}\) simplesmente elimina o último dígito hexadecimal, assim como dividir por 10 elimina o último dígito em decimal.
Exemplo prático: multiplicação
Calcule \(2F_{16} \times 10_{16}\). Em decimal, \(47 \times 16 = 752\). Convertendo de volta: \(752 \div 16 = 47\) r \(0\); \(47 \div 16 = 2\) r \(15 = F\); \(2 \div 16 = 0\) r \(2\) → \(2F0_{16}\). Multiplicar por \(10_{16}\) acrescenta um zero no final, exatamente como multiplicar por 10 faz em decimal.
Principais termos de hexadecimal definidos
| Termo | Definição |
|---|---|
| Hexadecimal (hex) | O sistema de numeração de base 16, que usa os dezesseis símbolos 0–9 e A–F. Cada posição vale 16 vezes a posição à sua direita. |
| Base / raiz (radix) | A quantidade de dígitos distintos que um sistema usa. O decimal tem base 10, o binário base 2, o hexadecimal base 16. Um subscrito como \(1D6_{16}\) indica a base explicitamente. |
| Dígito hexadecimal | Um símbolo de um número hexadecimal, representando um valor de 0 a 15. A, B, C, D, E, F representam 10, 11, 12, 13, 14, 15. |
| Nibble | Quatro bits — exatamente um dígito hexadecimal, com 16 valores possíveis (0–F). |
| Byte | Oito bits — exatamente dois dígitos hexadecimais, cobrindo de 0x00 a 0xFF (0 a 255 sem sinal). |
| Palavra (word) | A unidade natural de dados de um determinado processador ou formato. Seu tamanho varia conforme a arquitetura: comumente 16 bits (4 dígitos hexadecimais), mas 32 ou 64 bits em outros casos. Sempre confira qual definição um documento ou manual de CPU utiliza. |
| Prefixo 0x | O marcador de estilo da linguagem C para um literal hexadecimal, como em 0x1F. É apenas notação e não acrescenta nada ao valor. |
| h no final | A convenção da linguagem assembly para a mesma coisa, como em 1Fh. Outras convenções incluem $1F, #1F e 16#1F#. |
| Dígito mais significativo (MSD) | O dígito mais à esquerda — aquele com o maior valor posicional e, portanto, o que mais altera o número. |
| Dígito menos significativo (LSD) | O dígito mais à direita, que vale \(16^0 = 1\). |
| Transporte (carry, "vai um") | Na adição, o 1 passado para a próxima coluna à esquerda quando o total de uma coluna chega a 16 ou mais. |
| Empréstimo (borrow) | Na subtração, a unidade tomada da próxima coluna à esquerda quando o dígito de cima é pequeno demais. Em hexadecimal, um empréstimo vale 16. |
| Divisão inteira (floor) | Divisão que produz um quociente inteiro, com a parte fracionária removida. Para operandos não negativos, truncar em direção a zero e arredondar para baixo dão o mesmo resultado; esta calculadora trunca em direção a zero. |
| Resto / módulo | O que sobra após a divisão inteira: \(a - b \times (a \div b)\). Para \(FF \div 10\), o resto é \(F\) (15). Esta calculadora o descarta. |
| Estouro (overflow) | O que acontece quando um resultado é grande demais para a largura de armazenamento em uso — por exemplo, somar 1 a um 0xFFFFFFFF de 32 bits dá a volta para 0x00000000 na aritmética de hardware de largura fixa. |
| Aritmética de inteiros de precisão arbitrária (big-integer) | Aritmética feita por software com números de comprimento arbitrário, limitada pela memória e não por um registrador fixo de 32 ou 64 bits. Evita o estouro, e é por isso que uma calculadora consegue lidar com valores hexadecimais muito maiores que uma palavra de CPU. |
| Representação sem sinal | Uma codificação em que todo padrão de bits é um valor não negativo: um byte de 8 bits vai de 0x00 a 0xFF, ou seja, de 0 a 255. |
| Representação com sinal | Uma codificação que reserva parte do intervalo para valores negativos. Os mesmos padrões de 8 bits passam a abranger de −128 a +127, de modo que 0xFF significa −1 e não 255. Se uma sequência hexadecimal tem sinal ou não depende inteiramente de como o programa que a usa a interpreta. |
| Complemento de dois | A forma quase universal de codificar inteiros com sinal: para negar um valor, inverta todos os bits e some 1. Em 8 bits, \(-1\) é 0xFF e \(-128\) é 0x80. Isso permite que um único circuito somador faça tanto adição quanto subtração. |
| Endereço de memória | Uma posição na memória, convencionalmente escrita em hexadecimal (por exemplo, 0x7FFF0000), pois o hexadecimal corresponde de forma limpa aos bits de endereço e aos limites de página. |
| Código de cor #RRGGBB | A notação web/CSS em que três pares de dígitos hexadecimais indicam os canais vermelho, verde e azul, cada um de 0x00 a 0xFF. #FF0000 é vermelho puro; #FFFFFF é branco; #000000 é preto. |
Duas observações práticas ao usar esses termos com qualquer calculadora hexadecimal: aqui os resultados são tratados como inteiros matemáticos comuns, e não como valores de máquina de largura fixa, portanto não ocorre estouro com retorno ao início; e a divisão devolve apenas o quociente truncado, então, se você também precisar do resto, terá de calculá-lo separadamente.
Perguntas frequentes
A divisão retorna uma fração ou um resto? Não. A divisão retorna apenas o quociente inteiro — por exemplo, 10 ÷ 3 (em hexadecimal) resulta no número inteiro, e qualquer resto é descartado.
Posso usar letras hexadecimais minúsculas? Sim. A leitura dos valores hexadecimais aceita tanto minúsculas (a–f) quanto maiúsculas (A–F). O resultado é sempre exibido em maiúsculas.
E se a subtração resultar em um número negativo? A calculadora trata isso corretamente e exibirá um resultado hexadecimal negativo, já que trabalha com inteiros de precisão arbitrária com sinal.