Bits e binário: por que o computador conta de dois em dois

Bits e binário: por que o computador conta de dois em dois

Quando um disco de 1 TB chega ao seu computador, o sistema pode mostrar algo perto de 931 GB. Ninguém roubou nada. O vendedor conta 1 TB como 1 000 000 000 000 bytes, e o sistema conta em potências de 2, com 1 GiB igual a 1 073 741 824 bytes. As duas contas estão certas, e a diferença entre elas é o primeiro assunto desta aula. Para entendê-la, é preciso voltar ao que o computador de fato guarda: não números, e sim estados de um componente que só aceita dois valores. Desse ponto em diante, tudo o que a máquina representa, de um inteiro a uma letra, passa por bits.

A aula segue a escada que a trilha usa: começa pelo bit em linguagem simples, explica por que a base 2 venceu, mostra exemplos de contextos diferentes, desce até a tensão num fio e a conversão entre bases, e termina com as operações bit a bit que o processador usa para ler e alterar partes de um número. Os programas citados foram executados no macOS de 1 de novembro de 2026, e as saídas estão coladas no texto.

Mapa da aula

1. O que é um bit

Pense numa lâmpada de corredor com um interruptor. Ela está acesa ou apagada, e não existe meio-termo para quem olha de longe. Um bit é isso: uma unidade que pode valer 0 ou 1. A palavra vem de binary digit, dígito binário, e a ideia é a mesma de um dígito decimal, que pode ser um entre dez valores. Com um bit só, a máquina distingue duas coisas. Com dois bits, distingue quatro. Com oito, distingue 256.

A analogia da lâmpada tem um limite claro. Uma lâmpada não guarda nada sozinha, ela só mostra o estado em que está. Um bit de memória precisa de um circuito que mantenha o estado, e de outro que o troque quando alguém pede. Esse circuito fica para a fase 2 da trilha. Por ora, o que importa é que o bit é uma escolha entre dois estados, e que todo o resto é combinação dessas escolhas.

Um grupo de oito bits forma um byte. Em um byte, a escolha pode ser feita 256 vezes diferentes, de 00000000 a 11111111. Esse número de combinações é o que faz o byte útil: uma letra, um pixel de cinza ou uma instrução de processador cabem nele. A figura abaixo mostra um byte com o peso de cada posição. Somando os pesos dos bits ligados, obtemos o número representado.

Cada bit tem um peso que é uma potência de 2: o bit mais à direita vale 1, o seguinte vale 2, depois 4, 8 e assim por diante. Assim, o padrão mostrado na figura é 128 + 32 + 16 + 4 + 2 = 182. A figura deixa visível o que o texto afirma: o valor de um byte é a soma dos pesos das posições ligadas, e nada mais. Mais adiante veremos que o byte é apenas a convenção mais comum para agrupar bits.

2. Por que base 2

Antes de existir eletrônica digital, máquinas de calcular usavam rodas com dez dentes, uma para cada dígito. Cada roda tinha dez posições, e a leitura dependia de saber em qual dente o mecanismo tinha parado. Esse sistema funciona, mas cada posição exige distinguir dez estados. Com fios elétricos, distinguir dez níveis de tensão é um problema de precisão, porque o ruído do circuito, que é inevitável, pode empurrar um nível para o vizinho.

A base 2 resolve isso de forma direta. Um fio com dois níveis, um alto e um baixo, deixa uma margem grande entre eles. Se a tensão cair um pouco, o circuito ainda lê o mesmo valor. A figura abaixo mostra como essa margem funciona num fio de exemplo.

A figura mostra três faixas. A faixa azul embaixo é lida como 0, a verde em cima como 1, e a laranja no meio é a zona proibida, onde o circuito não sabe o que ler. O sinal real, a linha laranja, sobe e desce com ruído e atravessa a zona durante as transições, mas quase todo o tempo fica dentro de uma das faixas seguras. Os valores de 0,8 V e 2 V são de exemplo, tirados da família TTL de 5 V, e não foram conferidos num datasheet nesta revisão. Outras famílias usam faixas diferentes.

Compare com dez níveis. Se cada um dos dez níveis ocupasse uma faixa de 0,5 V dentro de 5 V, qualquer ruído acima de 0,25 V já mudaria o dígito lido. Com dois níveis, a faixa de cada um pode ocupar a maior parte da escala, e o ruído precisa ser muito grande para causar erro. Esse é o motivo prático da base 2: ela é mais robusta para circuitos.

A analogia da conversa numa sala barulhenta ajuda aqui. Dizer “sim” ou “não” é fácil de entender mesmo com ruído, mas tentar distinguir dez tons de voz diferentes numa festa dá erro. O limite dessa analogia é importante: a voz humana não se regenera, e o circuito digital sim. Cada porta lógica devolve o sinal ao nível cheio, então o ruído que entra numa etapa não se acumula na próxima. Essa regeneração é o que torna o bit confiável em bilhões de operações.

3. Exemplos em contextos diferentes

O mesmo padrão de bits aparece em lugares muito diferentes, e o significado depende de quem lê. Vale olhar três casos.

O primeiro é o endereço IPv4. Um endereço como 192.168.0.1 tem quatro números de 0 a 255, e cada número ocupa exatamente um byte. Em binário, 192 é 11000000, 168 é 10101000, 0 é 00000000 e 1 é 00000001. Quando um roteador decide se um pacote pertence à sua rede, ele compara bits, e não números decimais. Esse é o motivo de máscaras de sub-rede terem a forma 255.255.255.0, que em binário é 24 uns seguidos e depois zeros.

O segundo é a cor. Um pixel vermelho, verde e azul costuma guardar um byte para cada canal, de 0 a 255. A cor laranja pura, por exemplo, é 255 de vermelho, 128 de verde e 0 de azul, escrita em hexadecimal como #FF8000. O mesmo byte 10000000, que vale 128, é um tom médio de verde em uma imagem e um endereço de memória em outra.

O terceiro é a permissão de arquivo em sistemas Unix. As permissões de leitura, escrita e execução de dono, grupo e outros formam nove bits, e a notação octal 644 é só uma forma de agrupar esses bits de três em três. Esse caso aparece com força no código da seção 6.

Nos três casos, o padrão 10000000 é o mesmo. O que muda é a convenção que diz o que cada bit significa. Por isso, um bit sozinho nunca basta para dizer o que um dado é: é preciso saber o tipo e o contexto.

4. Como funciona

Convertendo entre bases

Converter um número decimal para binário é repetir uma divisão por 2 e guardar os restos. O primeiro resto é o bit menos significativo, o da direita, e o último resto é o bit mais significativo, o da esquerda. Vamos converter 182 passo a passo:

Lendo os restos de baixo para cima, obtemos 10110110. Para conferir, some os pesos dos bits ligados: 128 + 32 + 16 + 4 + 2 = 182. A conversão inversa é ainda mais direta: multiplique cada bit por seu peso (2 elevado à posição) e some.

O código abaixo implementa exatamente esse algoritmo. Ele foi executado com Python 3.12, e a saída é a real.

def para_binario(n):
    """Converte inteiro não negativo para string binária por divisões sucessivas por 2."""
    if n == 0:
        return "0"
    bits = []
    while n > 0:
        bits.append(str(n % 2))   # o resto da divisão por 2 é o bit menos significativo
        n //= 2                   # o quociente segue para o próximo bit
    return "".join(reversed(bits))

valor = 182
print("decimal 182 -> binário", para_binario(valor), "-> hexadecimal", hex(valor))
print("binário 10110110 -> decimal", int("10110110", 2), "-> hexadecimal", format(int("10110110", 2), "X"))
print("hexadecimal B6 -> decimal", int("B6", 16), "-> binário", format(int("B6", 16), "08b"))

decimal 182 -> binário 10110110 -> hexadecimal 0xb6
binário 10110110 -> decimal 182 -> hexadecimal B6
hexadecimal B6 -> decimal 182 -> binário 10110110

A máquina que rodou isso é um Mac com processador ARM, e o resultado não depende dela: a conversão é matemática pura.

O hexadecimal existe porque binário é longo. Cada dígito hexadecimal corresponde a exatamente quatro bits, porque 16 é 2 elevado a 4. Assim, o byte 10110110 vira duas letras, B e 6. A figura abaixo mostra essa divisão em dois grupos de quatro.

Por isso, em dumps de memória e em endereços, o hexadecimal aparece no lugar do binário: 0xB6 é curto e a conversão para bits é mecânica, sem nenhuma conta. A convenção de prefixo 0x vem de linguagens como C, e não é um padrão do próprio hexadecimal.

Como um bit vira tensão

No circuito real, um bit é uma tensão medida num ponto. A figura abaixo mostra o caso mais simples: uma chave conecta uma fonte de 5 V ao fio, e um resistor puxa o fio para baixo quando a chave está aberta.

Com a chave fechada, o fio fica perto de 5 V e é lido como 1. Com a chave aberta, o resistor leva o fio a 0 V e ele é lido como 0. O resistor de puxada, ou pull-down, existe para que o fio nunca fique flutuando, sem nível definido, quando a chave está aberta. Essa é a relação entre o bit lógico e a eletricidade: o bit é a leitura de uma faixa de tensão, e as faixas da figura anterior, sobre as faixas de tensão, são o que o circuito realmente considera.

Na prática, cada porta lógica é um circuito que lê essas faixas e devolve um nível cheio na saída. Por isso o ruído não se acumula. Um sinal que chega a 4,6 V em vez de 5 V continua sendo 1 para a próxima porta, e a saída volta a ser 5 V. A regeneração é uma das razões pelas quais processadores com bilhões de transistores conseguem operar sem acumular erro. O transistor em si é assunto da fase 2.

Operações lógicas básicas

Com um bit, há quatro operações de uma entrada ou duas entradas que importam para esta aula. A porta E (AND) devolve 1 só quando as duas entradas valem 1. A porta OU (OR) devolve 1 quando pelo menos uma entrada vale 1. A porta XOR devolve 1 quando as entradas são diferentes. A porta NÃO inverte o bit. A figura abaixo mostra as portas com a tabela-verdade de cada uma, e a linha destacada corresponde às entradas 1 e 0.

A linha destacada mostra o caso que mais confunde quem começa: as entradas 1 e 0. A porta E devolve 0, a porta OU devolve 1 e a XOR devolve 1. A figura da trilha sobre álgebra booleana (ainda a ser escrita) explica essas portas em detalhe. Aqui elas servem como ferramentas para operar sobre bits inteiros, na seção seguinte.

5. Byte, palavra e unidades

Byte e palavra

Um byte tem oito bits e é a unidade de endereçamento da maioria das máquinas: cada endereço de memória aponta para um byte, e não para um bit. A palavra é a quantidade de bits que a CPU manipula de uma vez, em geral num registrador. Ela varia com a arquitetura: processadores de 32 bits trabalham com palavras de 32 bits, e os de 64 bits, com palavras de 64. A palavra é uma propriedade do processador, e o byte é uma convenção de memória que quase todos adotaram.

Como cada bit dobra o número de combinações, o tamanho em bits diz quantos valores distintos cabem. A figura abaixo mostra essa curva em escala logarítmica: o número de valores cresce tão depressa que um eixo linear não caberia no papel.

A curva é uma reta na escala logarítmica, o que quer dizer crescimento exponencial. Com 8 bits há 256 valores, com 16 bits há 65 536, com 32 bits há 4 294 967 296 e com 64 bits há 18 446 744 073 709 551 616. Esse último número é tão grande que, se um contador incrementasse um bilhão de vezes por segundo, levaria centenas de anos para dar a volta. Esse cálculo é aritmética direta e não uma medição de sistema.

KB, KiB e o disco de 1 TB

Aqui está a origem da confusão da abertura. Em engenharia e em marketing de armazenamento, o prefixo quilo segue o SI e significa 1000. Em computação, durante décadas, o mesmo nome foi usado para 1024, que é 2 elevado a 10, porque os endereços são binários. Para acabar com a ambiguidade, a IEC criou prefixos próprios para as potências de 2: kibi (Ki), mebi (Mi), gibi (Gi) e tebi (Ti). O kibibyte vale 1024 bytes, conforme o NIST e o vocabulário IEC.

A diferença cresce com o prefixo. Um megabyte decimal são 1 000 000 bytes, e um mebibyte são 1 048 576, uma diferença de 4,86%. No giga, a diferença passa de 7%, e no tera chega a quase 10%. Um disco de 1 TB decimal tem 10 elevado a 12 bytes. Dividido por 2 elevado a 30, que é um GiB, dá 931,3 GiB. A figura abaixo compara as duas contagens com os valores arredondados.

A barra da esquerda é o número que o fabricante escreve na caixa. A da direita é o número que um sistema que conta em potências de 2 mostra. Nenhum dos dois erra: são unidades diferentes com o mesmo nome. O erro comum é achar que o disco perdeu espaço. O espaço é o mesmo, a régua é que mudou. Os sistemas operacionais não seguem uma convenção única para mostrar esses valores, e a figura apenas ilustra a conta, sem afirmar qual sistema usa qual unidade.

6. Operações bit a bit

Até aqui, um bit era lido ou comparado. A CPU faz mais do que isso: ela opera sobre todos os bits de uma palavra de uma vez, com as portas da seção 4 aplicadas em paralelo, uma por posição. Essas operações são a base de máscaras, de flags e de vários cálculos rápidos.

AND, OR, XOR e NOT sobre bytes

Com dois bytes, a operação é aplicada posição por posição. O programa abaixo faz isso com 8 bits e mostra o resultado de cada operação.

a = 0b11001010
b = 0b10101100
print(f"  a      = {a:08b}")
print(f"  b      = {b:08b}")
print(f"  a & b  = {a & b:08b}  (AND: 1 só onde os dois são 1)")
print(f"  a | b  = {a | b:08b}  (OR: 1 onde pelo menos um é 1)")
print(f"  a ^ b  = {a ^ b:08b}  (XOR: 1 onde são diferentes)")
print(f"  ~a&0xFF= {(~a) & 0xFF:08b}  (NOT dentro de 8 bits)")
print(f"  a << 1 = {(a << 1) & 0xFF:08b}  (desloca à esquerda; o bit 7 sai da janela de 8 bits)")
print(f"  a >> 3 = {a >> 3:08b}  (desloca à direita; bits que descem somem)")

  a      = 11001010
  b      = 10101100
  a & b  = 10001000  (AND: 1 só onde os dois são 1)
  a | b  = 11101110  (OR: 1 onde pelo menos um é 1)
  a ^ b  = 01100110  (XOR: 1 onde são diferentes)
  ~a&0xFF= 00110101  (NOT dentro de 8 bits)
  a << 1 = 10010100  (desloca à esquerda; o bit 7 sai da janela de 8 bits)
  a >> 3 = 00011001  (desloca à direita; bits que descem somem)

O deslocamento merece atenção. Deslocar um número à esquerda uma posição multiplica por 2, e à direita divide por 2 com descarte da parte fracionária. A figura abaixo mostra um deslocamento de três posições, em que cada bit sobe e zeros entram à direita.

O valor 13 vira 104 porque 13 vezes 8 é 104. Essa é a base de uma multiplicação rápida: 13 vezes 10 dá o mesmo que 13 deslocado três posições mais 13 deslocado uma posição, 104 + 26 = 130. O processador faz deslocamentos num ciclo, e uma multiplicação completa leva mais passos. Por isso compiladores trocam multiplicações por potências de 2 por deslocamentos.

Máscaras

Uma máscara é um padrão de bits usado para isolar, ligar ou desligar partes de um número. A operação mais comum é o AND com máscara: onde a máscara vale 1, o bit do dado passa; onde vale 0, o bit é zerado. A figura abaixo mostra um exemplo com um dado de 8 bits.

O dado é 10110110 e a máscara é 00001100, com os bits 2 e 3 ligados. O AND deixa passar só o bit 2 do dado, que vale 1, e o bit 3, que vale 0, sai como 0. O resultado, 00000100, é o dado com todo o resto apagado. Para ligar um bit sem mexer nos outros, usa-se OR com a máscara do bit. Para desligar, usa-se AND com o complemento da máscara, que é o que a linha byte & ~(1<<2) do exemplo abaixo faz.

Flags de um arquivo aberto

O caso real mais útil é o das flags de abertura de arquivo. Quando um programa chama open() no Unix, ele passa um número em que cada bit liga uma opção, como criar o arquivo se não existir ou escrever sempre no fim. O programa abaixo usa as constantes do próprio sistema, lidas de fcntl.h, e combina e testa essas opções com OR e AND.

#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>

int main(void) {
    printf("O_WRONLY = 0x%04x  (%s)\n", O_WRONLY, "bit de modo de acesso");
    printf("O_CREAT  = 0x%04x\n", O_CREAT);
    printf("O_APPEND = 0x%04x\n", O_APPEND);

    int flags = O_WRONLY | O_CREAT | O_APPEND;   /* OR junta os bits */
    printf("\nflags = O_WRONLY | O_CREAT | O_APPEND = 0x%04x = %d\n", flags, flags);
    printf("tem O_CREAT?  %s\n", (flags & O_CREAT) ? "sim" : "nao");   /* AND testa o bit */
    printf("tem O_TRUNC?  %s\n", (flags & O_TRUNC) ? "sim" : "nao");

    flags &= ~O_APPEND;                           /* NOT + AND desliga o bit */
    printf("sem O_APPEND: 0x%04x\n", flags);

    mode_t pedido = 0666;
    mode_t umask_tipica = 022;
    mode_t efetivo = pedido & ~umask_tipica;
    printf("\npedido 0666 & ~umask 022 = %04o (dono rw, grupo r, outros r)\n", efetivo);
    printf("bits do dono: r=%d w=%d x=%d\n", !!(efetivo & 0400), !!(efetivo & 0200), !!(efetivo & 0100));
    return 0;
}

O_WRONLY = 0x0001  (bit de modo de acesso)
O_CREAT  = 0x0200
O_APPEND = 0x0008

flags = O_WRONLY | O_CREAT | O_APPEND = 0x0209 = 521
tem O_CREAT?  sim
tem O_TRUNC?  nao
sem O_APPEND: 0x0201

pedido 0666 & ~umask 022 = 0644 (dono rw, grupo r, outros r)
bits do dono: r=1 w=1 x=0

Os valores de O_CREAT, O_APPEND e O_WRONLY são os do macOS, lidos do cabeçalho local, e no Linux eles são outros números. A figura abaixo mostra a palavra de 16 bits com as três flags ligadas.

Os bits destacados são o 9, o 3 e o 0. Eles correspondem às três constantes lidas pelo programa: 0x200 é o bit 9, 0x008 é o bit 3 e 0x001 é o bit 0. A soma 0x209 é o OR das três, e a operação flags &= ~O_APPEND apaga só o bit 3, deixando 0x201. Ler o programa com essa figura ao lado mostra o que cada linha faz com a palavra.

A umask, nas duas últimas linhas, é outro exemplo do mesmo mecanismo. O pedido de permissão 0666 tem bits ligados para leitura e escrita de todos. A umask 022 é uma máscara de bits que desliga a escrita do grupo e dos outros. O AND com o complemento da máscara deixa 0644. Nenhuma linha depende de adivinhar o resultado: é a mesma operação bit a bit aplicada posição por posição.

7. Erros comuns e boas práticas

O primeiro erro é misturar KB e KiB. Quem escreve um programa que aloca “1 MB” de memória e não diz qual dos dois quer acaba com um buffer 4,86% menor do que imaginava. Em código, prefira escrever a potência de 2 de forma explícita, como 1 << 20, quando o número é de endereçamento, e 10**6 quando é uma medida de transferência. Todo mundo confunde KB e KiB uma vez, e quem diz que nunca confundiu ainda não olhou para uma tabela de tamanhos com atenção.

O segundo erro é tratar o hexadecimal como outro tipo de número. 0xB6 e 182 são o mesmo valor, escritos de formas diferentes. Quando um valor parece “estranho”, converta antes de concluir que a conta está errada.

O terceiro erro é deslocar além da largura do tipo. Com 8 bits, a << 1 perde o bit 7, e um programa que supõe que o valor cresceu vai ler um número menor. Em C e em outras linguagens com tipos de largura fixa, o deslocamento precisa caber no tipo escolhido.

O quarto erro, que aparece em código C real, é a precedência do operador ==. Em C, == tem precedência maior que &. A expressão flags & O_CREAT == O_CREAT é lida como flags & (O_CREAT == O_CREAT), que testa o bit 0 e não o bit 9. A forma correta é (flags & O_CREAT) == O_CREAT, com parênteses. Essa é uma regra da linguagem, que todo compilador segue.

O quinto erro é achar que um bit sozinho diz o que um dado é. O padrão 10000000 pode ser o número 128, um tom de verde ou um endereço. O que dá sentido ao bit é o tipo do dado, e por isso os formatos de arquivo e de rede declaram tamanhos e significados. A boa prática é documentar a convenção junto do dado, como faz um cabeçalho de protocolo.

8. Exercícios

1. Converta 11010010 para decimal e para hexadecimal. Resposta: 128 + 64 + 16 + 2 = 210, e em hexadecimal 0xD2. Os dígitos são 1101 = D e 0010 = 2.
2. Quantos bits são necessários para guardar 300 valores distintos? Resposta: 2 elevado a 8 é 256, que não basta, e 2 elevado a 9 é 512. São necessários 9 bits.
3. Um arquivo tem 1 GB decimal (10 elevado a 9 bytes). Quantos GiB ele ocupa? Resposta: 10 elevado a 9 dividido por 2 elevado a 30 é cerca de 0,931 GiB.
4. Com a máscara 0x0F, qual é o resultado de 0xB6 AND 0x0F? Resposta: 0xB6 é 1011 0110, e a máscara deixa só os quatro bits de baixo, que são 0110, ou seja, 0x06, que vale 6.
5. Quantas combinações distintas cabem em 12 bits? Resposta: 2 elevado a 12, que é 4096.
6. Com o valor 0x36, ligue o bit 7 sem mexer nos outros. Qual é a operação e o resultado? Resposta: OR com 0x80, dando 0xB6, porque 0x36 é 0011 0110 e o bit 7 passa a valer 1.

Glossário

Bit: unidade de informação com dois estados possíveis, 0 ou 1.

Byte: grupo de oito bits, a unidade de endereçamento da memória na maioria das máquinas.

Palavra: quantidade de bits que a CPU manipula de uma vez, por exemplo 32 ou 64.

Binário: sistema de base 2, com dígitos 0 e 1.

Hexadecimal: sistema de base 16, em que cada dígito corresponde a quatro bits.

Máscara: padrão de bits usado para isolar, ligar ou desligar partes de um número.

Flag: bit que liga ou desliga uma opção.

Deslocamento: operação que move os bits para a esquerda ou para a direita, equivalente a multiplicar ou dividir por potências de 2.

Faixa de tensão: intervalo de tensão que o circuito lê como 0 ou como 1.

KiB: kibibyte, 1024 bytes, com o prefixo binário definido pela IEC.

O que não foi confirmado ou medido

Os valores de 0,8 V e 2 V da família TTL de 5 V são usados como exemplo e não foram conferidos em nenhum datasheet nesta revisão. Outras famílias têm faixas diferentes.

A definição de KB como 1000 bytes veio só de fontes secundárias, espelhos de páginas da Wikipedia e índices de busca. Não consultei o texto da norma IEC 80000-13 diretamente. O kibibyte como 1024 bytes foi confirmado pelo NIST e pela Electropedia.

Os valores das constantes de open() (O_CREAT, O_APPEND, O_WRONLY) foram medidos no macOS desta revisão, a partir do cabeçalho local. No Linux e em outras versões do sistema os valores podem ser diferentes.

A conta de 931 GiB para 1 TB decimal é aritmética, e não uma medição de algum sistema operacional específico. A figura do disco ilustra a conta, sem afirmar qual sistema mostra qual unidade.

As figuras de circuito e de tensão são ilustrativas. O circuito não foi simulado e não representa um dispositivo real medido.

Fontes

Consultadas em 1 de novembro de 2026.

• NIST, glossário, verbete “kibibyte”: define como 2 elevado a 10 bytes, ou 1024 bytes. https://csrc.nist.gov/glossary/term/kibibyte
• IEC Electropedia, IEV 1.024 bytes para kibibyte, referente à IEC 80000-13:2008. https://electropedia.org/iev/iev.nsf/17127c61f2426ed8c1257cb5003c9bec/e80750e32db7deb9c125839800589831
• Python 3.12, saídas dos programas desta aula, executadas em 1 de novembro de 2026 com Python 3.12.8.
• Cabeçalho fcntl.h do macOS, lido localmente para os valores de O_* citados na seção 6.

Relacionados

• Trilha de Hardware
• CPU
• Inteiros, complemento de dois e overflow
• Ponto flutuante
• Texto, ASCII, Unicode e UTF-8
• Álgebra booleana e portas lógicas