Calculadora
MatemáticaCalculadora Hexadecimal
Calculadora hex para programadores: AND/OR/XOR/NOT, deslocamentos e aritmética com largura de bits 8/16/32/64 ou BigInt, saída com sinal em complemento de dois, hex/dec/binário.
Tem feedback? Reporte bugs, sugira recursos ou compartilhe suas ideias — lemos todosComo Calcular em Hexadecimal?
Hexadecimal (base-16) é um sistema numérico que usa 16 símbolos: 0-9 e A-F. É comumente usado em programação de computadores e sistemas digitais. Cada posição representa uma potência de 16.
Convertendo Hexadecimal para Decimal:
- Escreva o número hexadecimal
- Multiplique cada dígito por 16 elevado à potência de sua posição (da direita para a esquerda, começando em 0)
- Some todos os resultados
0xFF = 15×16¹ + 15×16⁰ = 240 + 15 = 255
Convertendo Decimal para Hexadecimal:
- Divida o número decimal por 16
- Anote o resto (converta 10-15 para A-F)
- Continue dividindo o quociente por 16 até que se torne 0
255 ÷ 16 = 15 remainder 15 → F
15 ÷ 16 = 0 remainder 15 → F
Result: 0xFF
Tabela de referência hexadecimal
| Decimal | Hexadecimal | Binary |
|---|---|---|
| 0 | 0x0 | 0000 |
| 1 | 0x1 | 0001 |
| 10 | 0xA | 1010 |
| 15 | 0xF | 1111 |
| 16 | 0x10 | 10000 |
| 255 | 0xFF | 11111111 |
| 256 | 0x100 | 100000000 |
Sobre esta calculadora hexadecimal
Informe dois números em qualquer combinação de bases — hex, decimal ou binário — escolha uma operação e uma largura de bits, e a calculadora devolve o resultado ao mesmo tempo em hex, decimal sem sinal, decimal com sinal e binário. O núcleo de cálculo usa BigInt, então no modo Arbitrária (BigInt) valores enormes como 0xFFFFFFFFFFFFFFFF rodam sem perda de precisão (0xFFFFFFFFFFFFFFFF + 1 = 0x10000000000000000). O seletor de largura de bits (8/16/32/64) faz as operações bitwise (AND, OR, XOR, NOT, deslocamentos) darem a volta dentro de um registrador fixo igual a C, Rust ou Python com máscara: NOT 0xFF em 8 bits dá 0x00, e resultados negativos aparecem como hex em complemento de dois e como decimal com sinal. Tudo roda no seu navegador — nada é enviado.
Perguntas Frequentes
Leia os dígitos hex da direita para a esquerda e multiplique cada um por uma potência crescente de 16. Para 0xFF: F×16¹ + F×16⁰ = 15·16 + 15·1 = 240 + 15 = 255. Para algo mais longo como 0x1A2B: 1·16³ + 10·16² + 2·16¹ + 11·16⁰ = 4096 + 2560 + 32 + 11 = 6699. A calculadora faz a conversão em um único passo — escolha 'Hex' na base de entrada e o decimal aparece logo abaixo.
Divida o decimal por 16 várias vezes, registrando cada resto. Lendo os restos de baixo para cima você obtém o valor em hex, escrevendo 10–15 como A–F. Exemplo para 255: 255 ÷ 16 = 15 resto 15 (F); 15 ÷ 16 = 0 resto 15 (F). De baixo para cima: FF. Logo 255 = 0xFF. A calculadora converte nas duas direções — escolha a base de origem no dropdown e o resultado aparece nas três bases.
As operações bitwise AND, OR e XOR atuam sobre a representação binária dos operandos, bit a bit. 0xFF AND 0x0F: em binário 11111111 AND 00001111 = 00001111 = 0x0F (mantém apenas o nibble baixo). 0xA0 OR 0x0B: 10100000 OR 00001011 = 10101011 = 0xAB (combina bits). 0xFF XOR 0x0F: 11111111 XOR 00001111 = 11110000 = 0xF0 (inverte os bits onde o segundo operando tem 1). São os blocos básicos de programação com máscaras de bit e dos truques sobre canais de cor.
O deslocamento à esquerda em n move todos os bits n posições para a esquerda e preenche com zeros à direita — equivalente a multiplicar por 2ⁿ. 0x0F << 4 = 0xF0 (um deslocamento de um nibble). O deslocamento à direita em n move os bits para a direita e descarta o que sai — equivalente a dividir inteiro por 2ⁿ. 0xFF >> 4 = 0x0F. Deslocamentos servem para empacotar/desempacotar canais RGB (red = (color >> 16) & 0xFF), interpretar formatos binários e implementar multiplicação/divisão rápida por potências de dois.
Cada par hex codifica um valor 00–FF (0–255), a intensidade de um canal de cor. #FF0000 é vermelho puro (R=255, G=0, B=0); #00FF00 é verde puro; #FFFFFF é branco. Três bytes encaixam exatamente em seis dígitos hex, por isso o formato é universal em CSS, ferramentas de design e APIs gráficas. Usar hex em vez de decimal mantém cada canal visualmente distinto (#FF6347 vs rgb(255, 99, 71)) e torna trivial o bit-masking de cada canal.
Não. 0x10 é dezesseis em hexadecimal — o prefixo '0x' avisa ao leitor (e ao compilador) que os dígitos estão na base 16. Sem prefixo, 10 é dez em decimal. Os mesmos dígitos podem significar valores diferentes conforme a base: 10 em binário é 2, 10 em hex é 16, 10 em decimal é 10. O dropdown de base ao lado de cada número permite indicar explicitamente, então nunca há ambiguidade sobre como o valor é interpretado.
Sim. Coloque o dropdown de largura de bits em Arbitrária (BigInt) e a aritmética não tem limite de largura: 0xFFFFFFFFFFFFFFFF + 1 = 0x10000000000000000 (17 dígitos hex), e você pode multiplicar ou deslocar valores muito acima de 256 bits sem perda de precisão. Se em vez disso escolher uma largura fixa (8/16/32/64 bits), o resultado é mascarado para esse tamanho de registrador e dá a volta — exatamente o que um uint8_t/uint32_t/uint64_t faria em C ou Rust.
Numa CPU real não existe um 'bit de sinal' separado — um valor negativo é guardado em complemento de dois dentro de um registrador de largura fixa, então a resposta depende inteiramente da largura de bits. Escolha 8/16/32/64 bits e a ferramenta mascara o resultado para essa largura: NOT 0xFF em 8 bits = 0x00, NOT 0x00 em 8 bits = 0xFF, e 5 − 10 em 32 bits mostra o hex sem sinal 0xFFFFFFFB ao lado do decimal com sinal −5. No modo Arbitrária (BigInt) não há registrador para dar a volta, então NOT e a subtração podem mostrar um valor com sinal de menos explícito em vez de complemento de dois. O campo Decimal com sinal sempre diz como um resultado de largura fixa é interpretado como inteiro com sinal.
Ajuste a largura ao registrador ou tipo que está analisando: 8 bits para um byte ou uint8_t, 16 bits para um short, 32 bits para um int típico, 64 bits para um long/ponteiro, ou Arbitrária (BigInt) para cálculo exato com números grandes sem volta. Overflow por volta significa que um resultado que não cabe na largura escolhida mantém apenas os bits baixos: 0xFF + 1 em 8 bits = 0x00 (deu a volta de 255 para 0), e 0xFFFFFFFF + 1 em 32 bits = 0x00000000. É o comportamento de que firmware, sistemas embarcados e engenharia reversa dependem, e bate com a aritmética inteira de C/Rust e com Python usando uma máscara & explícita.
Endereços de memória aparecem em hex (um ponteiro como 0x7fff5fbff7c0 é mais fácil de ler que sua forma decimal de 13 dígitos). Flags de bits e máscaras de permissão usam constantes hex (modos de arquivo Unix como 0644, bits de flag de registrador como 0x80000000). Hashes criptográficos e UUIDs aparecem em hex. Valores de cor em CSS, IDs de assets em engines de jogo, opcodes em desassembladores e códigos de erro do Windows (0x80070005 'acesso negado') são hex. Esta calculadora é pensada exatamente para os cálculos que você faz ao depurar ou ler documentação sobre qualquer um desses casos.
CALCULADORAS MATEMáTICAS32
WUTOOLS