Linguagem C: guia completo do hardware aos ponteiros

Quase tudo o que você usa hoje roda, em algum nível, sobre código escrito em C. O kernel do Linux, o interpretador oficial do Python (CPython), o SQLite que vive dentro de todo celular e navegador, o Redis, o Git, o PostgreSQL, o nginx, o curl, o firmware do micro-ondas e do controle remoto do portão. C tem mais de 50 anos e continua sendo a língua franca entre o software e o hardware.

Este guia foi escrito para ser a referência que eu gostaria de ter tido quando comecei: ele não começa no printf, começa no transistor. Vamos subir camada por camada, bits, portas lógicas, CPU, cache, memória virtual, até chegar a ponteiros, alocação dinâmica, structs, Makefiles, depuração com GDB e um projeto completo. Tudo em português, com exemplos que compilam de verdade.

1. Por que aprender C (ainda) em 2026

C é chamada de linguagem de "baixo nível" (ou, mais precisamente, de nível médio) porque os conceitos dela se mapeiam quase diretamente no que o hardware faz. Uma variável int é um punhado de bytes em um endereço de memória. Um ponteiro é, literalmente, um número que guarda esse endereço. Uma soma vira uma instrução add da CPU. Não existe coletor de lixo, não existe máquina virtual no meio do caminho, não existe verificação automática de limites de array. Você manda; a máquina obedece, inclusive quando você manda errado.

Isso traz três consequências práticas:

• Desempenho previsível. O custo de cada linha é visível. Por isso C domina sistemas operacionais, bancos de dados, drivers, compiladores, runtimes de outras linguagens e sistemas embarcados.
• Portabilidade. Existe um compilador C para praticamente toda CPU já fabricada, do microcontrolador de 8 bits ao supercomputador. C é às vezes chamada de "assembly portátil".
• A interface universal. Quando Python, Rust, Go, Node.js ou Java precisam conversar com uma biblioteca nativa, eles usam a interface binária (ABI) de C. Aprender C é aprender a língua em que os outros programas conversam entre si.

E há um benefício que vale para qualquer desenvolvedor, mesmo quem nunca vai escrever C profissionalmente: entender C é entender o que acontece por baixo de todas as outras linguagens. Quando você souber o que é a pilha, o heap, uma cache miss ou um ponteiro pendurado, vai escrever JavaScript, Python ou Java melhores.

O que você vai aprender

• Como bits, transistores, CPU, registradores, caches e RAM funcionam, e por que isso importa para o seu código.
• Como números inteiros, negativos (complemento de dois), números com vírgula (IEEE 754) e texto (ASCII e UTF-8) são guardados em bits.
• O que é memória virtual, como um processo é organizado na memória e o que é, fisicamente, um ponteiro.
• O caminho completo do arquivo .c até o executável: pré-processador, compilador, montador e linker.
• Como instalar o GCC no Windows, macOS e Linux, e quais flags usar no dia a dia.
• Toda a linguagem: tipos, operadores, entrada e saída, controle de fluxo, funções, escopo, arrays, strings, ponteiros, memória dinâmica, structs, unions, enums, pré-processador, múltiplos arquivos e arquivos em disco.
• Tratamento de erros, comportamento indefinido, depuração com GDB, sanitizers e Valgrind.
• Um mini projeto completo com lista encadeada, malloc/free e persistência em arquivo.
• Uma cola de consulta rápida no estilo pôster, com os comandos e funções mais usados.

Uma brevíssima história do C

C nasceu no Bell Labs, nos Estados Unidos, entre 1969 e 1973, pelas mãos de Dennis Ritchie. Ela evoluiu da linguagem B, criada por Ken Thompson, que por sua vez derivava do BCPL. O objetivo era muito concreto: reescrever o sistema operacional Unix em uma linguagem de alto nível sem perder o controle sobre o hardware. Em 1973 o kernel do Unix foi reescrito em C, algo ousado para a época, e isso tornou o Unix portável para outras máquinas.

Em 1978, Brian Kernighan e Dennis Ritchie publicaram o livro The C Programming Language, conhecido como "K&R", que virou o padrão de fato por mais de uma década. Depois vieram os padrões oficiais:

O C23 foi publicado pela ISO como ISO/IEC 9899:2024. Neste guia usamos C17 como base, porque é o padrão mais bem suportado por todos os compiladores, e apontamos as novidades do C23 quando elas ajudam.

O que você vai precisar

• Um computador com Windows, macOS ou Linux.
• Um terminal (PowerShell, Terminal do macOS ou o terminal da sua distro). Se o terminal ainda te intimida, o guia de comandos do terminal Linux ajuda bastante.
• Um editor de código (o VS Code é uma ótima escolha, veremos adiante).
• Nenhum conhecimento prévio de C. Ter noções de lógica de programação em qualquer linguagem ajuda, mas não é obrigatório.

2. Como um computador funciona, de baixo para cima

Para entender C de verdade, precisamos entender a máquina que ele controla. Esta seção sobe do nível físico até a CPU executando instruções. Não é um curso de engenharia elétrica, mas cada conceito aqui vai reaparecer mais adiante, quando falarmos de tipos, ponteiros e desempenho.

Bits: a menor unidade de informação

Um bit (de binary digit, dígito binário) é a menor unidade de informação possível: ele só pode valer 0 ou 1. Fisicamente, um bit é qualquer coisa que tenha dois estados bem distinguíveis:

• Dentro da CPU: um nível de tensão elétrica baixo (0) ou alto (1) em um fio do circuito.
• Na memória RAM (DRAM): um capacitor minúsculo carregado ou descarregado.
• No SSD: elétrons aprisionados (ou não) em uma célula de memória flash.
• No HD mecânico: a direção da magnetização de uma região do disco.

Por que dois estados e não dez, como os dígitos decimais? Porque distinguir "tem tensão" de "não tem tensão" é robusto contra ruído, variação de temperatura e imprecisão de fabricação. Se o circuito tivesse de diferenciar dez níveis de tensão, qualquer interferência viraria erro. Com dois níveis, há uma margem enorme entre eles.

Além disso, com dois estados podemos usar a álgebra booleana (George Boole, 1854), em que tudo é verdadeiro ou falso. Em 1937, Claude Shannon mostrou em sua dissertação de mestrado que circuitos de relés podiam implementar essa álgebra, e isso abriu caminho para todo computador digital desde então.

Transistores: interruptores controlados por eletricidade

O componente que manipula bits é o transistor. Nos chips modernos, o tipo usado é o MOSFET, que funciona como um interruptor sem partes móveis: uma tensão aplicada em um terminal (a porta, ou gate) decide se a corrente pode ou não passar entre os outros dois terminais. Ligado ou desligado. 1 ou 0.

Um único transistor não faz muita coisa. Mas processadores atuais têm bilhões deles (os maiores chips de consumo já passam de dezenas de bilhões), organizados em estruturas cada vez mais complexas. A primeira dessas estruturas é a porta lógica.

Portas lógicas: o hardware que calcula

Combinando alguns transistores, construímos portas lógicas: circuitos que recebem um ou mais bits e produzem um bit de saída segundo uma regra fixa. As principais:

• NOT inverte o bit.
• AND só dá 1 se as duas entradas forem 1.
• OR dá 1 se pelo menos uma entrada for 1.
• XOR (ou exclusivo) dá 1 se as entradas forem diferentes.
• NAND é o AND invertido. Curiosidade: ele é universal, ou seja, qualquer outra porta pode ser construída só com NANDs.

Guarde essa tabela: em C, os operadores ~, &, | e ^ fazem exatamente essas operações, bit a bit, sobre números inteiros de 8, 16, 32 ou 64 bits. Veremos isso na seção de operadores.

Agora a mágica: com portas lógicas dá para somar. Um meio somador soma dois bits:

  A ─┬──────────[ XOR ]────▶ S (soma)        A B │ S  C
     │    ┌────▶[     ]                      ────┼──────
  B ─┼────┤                                  0 0 │ 0  0
     │    └────▶[ AND ]────▶ C (vai-um)      0 1 │ 1  0
     └─────────▶[     ]                      1 0 │ 1  0
                                             1 1 │ 0  1   ← 1 + 1 = 10 em binário

A soma é A XOR B e o "vai-um" (carry) é A AND B. Encadeando 64 somadores completos (que também consideram o vai-um que chega da coluna anterior), temos um circuito que soma dois números de 64 bits, exatamente como você somava na escola, coluna por coluna, só que em base 2.

Com o mesmo princípio de portas realimentando umas às outras, constroem-se circuitos que lembram um bit (os flip-flops e latches). Juntando flip-flops, temos os registradores. E há dois tipos principais de memória feitos de transistores:

• SRAM (RAM estática): cerca de 6 transistores por bit. Muito rápida, cara e ocupa bastante área do chip. É usada nas caches da CPU.
• DRAM (RAM dinâmica): 1 transistor e 1 capacitor por bit. Muito mais densa e barata, porém mais lenta, e o capacitor vaza carga, então a memória precisa ser "refrescada" periodicamente (tipicamente a cada 64 ms). É a memória RAM do computador.

A CPU por dentro: controle, ULA, registradores e clock

A CPU (Central Processing Unit, unidade central de processamento) é o circuito que executa as instruções do programa. Simplificando bastante, cada núcleo de uma CPU tem estas partes:

┌──────────────────────── Núcleo da CPU ────────────────────────┐
│                                                               │
│  ┌──────────────────┐  sinais de  ┌────────────────────────┐  │
│  │ Unidade de       │  controle   │ Registradores          │  │
│  │ controle         │────────────▶│ rax rbx rcx rdx ...    │  │
│  │ busca/decodifica │             │ rip (PC)   rflags      │  │
│  └────────┬─────────┘             └───────────┬────────────┘  │
│           │                                   │ operandos     │
│           ▼                                   ▼               │
│  ┌──────────────────┐             ┌────────────────────────┐  │
│  │ Cache L1         │◀───────────▶│ ULA (ALU)              │  │
│  │ instruções/dados │             │ + - * & | ^ << >> cmp  │  │
│  └────────┬─────────┘             └────────────────────────┘  │
│           │                                                   │
└───────────┼───────────────────────────────────────────────────┘
            ▼
     Cache L2  ──▶  Cache L3 (compartilhada)  ──▶  RAM

• Unidade de controle: busca a próxima instrução, decodifica o que ela significa e gera os sinais que coordenam o resto do núcleo.
• ULA (Unidade Lógica e Aritmética, ou ALU em inglês): o circuito que efetivamente soma, subtrai, multiplica, compara e faz as operações bit a bit. CPUs modernas têm várias ULAs e também unidades dedicadas a ponto flutuante e a instruções vetoriais (SIMD).
• Registradores: pequenas memórias dentro do núcleo, as mais rápidas do computador. Na arquitetura x86-64 há 16 registradores de uso geral de 64 bits (rax, rbx, rcx, rdx, rsi, rdi, rbp, rsp e r8 a r15). Na ARM64 há 31 (x0 a x30), além do ponteiro de pilha.
• Contador de programa (PC): um registrador especial que guarda o endereço da próxima instrução. No x86-64 ele se chama rip (instruction pointer); no ARM64, pc.
• Registrador de flags: bits que registram o resultado da última operação, se deu zero (ZF), se houve vai-um (CF), se o resultado é negativo (SF), se houve overflow com sinal (OF). As instruções de desvio condicional (os if do assembly) consultam essas flags.
• Clock: um sinal que oscila bilhões de vezes por segundo e sincroniza tudo. Uma CPU de 3 GHz tem 3 bilhões de ciclos por segundo, ou seja, um ciclo dura cerca de 0,33 nanossegundo.

Processadores atuais têm vários núcleos (cores), cada um com seus próprios registradores e caches L1 (e geralmente L2), compartilhando a cache L3 e a RAM. Muitos núcleos também executam duas threads de hardware ao mesmo tempo (o Hyper-Threading da Intel, genericamente chamado de SMT).

ISA: o contrato entre software e hardware

A CPU não entende C. Ela entende instruções de máquina: sequências de bytes que codificam operações simples como "some estes dois registradores" ou "carregue 8 bytes deste endereço". O conjunto de instruções que uma família de processadores entende, junto com seus registradores e regras, se chama ISA (Instruction Set Architecture). É o contrato entre software e hardware.

A mesma linha de C vira instruções diferentes em cada ISA. A função int soma(int a, int b) { return a + b; }, compilada com otimização, vira algo como lea eax, [rdi+rsi] no x86-64 e add w0, w0, w1 no ARM64. É isso que torna C portável: você escreve uma vez, e o compilador traduz para a ISA de destino. Existe ainda a RISC-V, uma ISA aberta e livre de royalties que vem ganhando espaço em microcontroladores e pesquisa.

O ciclo buscar–decodificar–executar

Todo processador, do mais simples ao mais moderno, executa programas repetindo o mesmo ciclo básico, bilhões de vezes por segundo:

1. Buscar (fetch): ler, na memória, os bytes da instrução que está no endereço apontado pelo PC.
2. Decodificar (decode): interpretar esses bytes, qual operação, quais registradores, qual endereço.
3. Executar (execute): a ULA realiza a operação (ou calcula um endereço).
4. Acessar a memória: se a instrução for de leitura ou escrita na memória.
5. Gravar o resultado (write-back): o resultado vai para um registrador.

Depois disso o PC avança para a próxima instrução, ou salta para outro endereço, se a instrução for um desvio (é assim que if, for e chamadas de função funcionam no nível da máquina). Veja a função soma compilada para x86-64, executando com a = 2 e b = 3:

endereço  bytes       instrução            o que acontece
────────  ──────────  ───────────────────  ────────────────────────────────────
0x1130    8d 04 37    lea eax, [rdi+rsi]   busca 3 bytes; decodifica; ULA soma
                                           rdi (2) + rsi (3); grava 5 em eax
0x1133    c3          ret                  busca 1 byte; lê o endereço de retorno
                                           da pilha e o coloca no PC

Os endereços são ilustrativos, mas os bytes 8d 04 37 e c3 são exatamente o que o GCC gera para essa função. Programa, no fim das contas, é isso: bytes na memória que a CPU interpreta como instruções.

Pipeline, execução fora de ordem e previsão de desvios

Executar uma instrução por vez, do começo ao fim, desperdiçaria o hardware: enquanto a ULA calcula, a unidade de busca ficaria parada. Por isso CPUs usam pipeline, como uma linha de montagem: enquanto uma instrução executa, a seguinte está sendo decodificada e a próxima está sendo buscada.

ciclo:        1     2     3     4     5     6     7
instrução 1:  BUSCA DECOD EXEC  MEM   GRAVA
instrução 2:        BUSCA DECOD EXEC  MEM   GRAVA
instrução 3:              BUSCA DECOD EXEC  MEM   GRAVA

Esse é o pipeline clássico de 5 estágios usado para ensino. CPUs modernas vão muito além:

• Superescalares: executam várias instruções por ciclo, em paralelo.
• Execução fora de ordem: reordenam instruções independentes para não ficarem esperando dados lentos.
• Previsão de desvios: quando chegam a um if, "chutam" qual caminho será tomado e começam a executá-lo antes de saber a resposta (execução especulativa). Se o chute estiver errado, o trabalho especulativo é descartado e a CPU perde vários ciclos.

Para quem programa em C, a lição prática é: desvios previsíveis e acessos sequenciais à memória são rápidos; desvios aleatórios e saltos pela memória são lentos. (Curiosidade: as vulnerabilidades Spectre e Meltdown, reveladas em 2018, exploravam justamente efeitos colaterais da execução especulativa.)

A hierarquia de memória: registradores, caches, RAM e SSD

Aqui está um dos fatos mais importantes da computação moderna: a CPU é muito mais rápida que a memória principal. Buscar um dado na RAM custa centenas de ciclos, tempo em que a CPU poderia ter executado centenas de instruções. A solução é uma hierarquia de memórias: pequenas e rápidas perto da CPU, grandes e lentas longe dela.

Para sentir a diferença, imagine que um ciclo de uma CPU de 3 GHz durasse 1 segundo. Nessa escala, ler da cache L1 levaria uns 4 segundos; da L3, perto de 40 segundos; da RAM, uns 5 minutos; de um SSD rápido, alguns dias; e de um HD mecânico, quase um ano.

As caches funcionam de forma automática e invisível para o programa: quando a CPU pede um byte, o hardware traz da RAM uma linha de cache inteira, tipicamente 64 bytes no x86-64 (os chips Apple M usam linhas de 128 bytes). A aposta é que, se você usou um byte, logo vai usar os vizinhos. Quando o dado já está na cache, temos um cache hit (rápido); quando não está, um cache miss (lento).

Barramentos: como os dados viajam

No modelo clássico de livro-texto, a CPU se comunica com a memória por três barramentos (conjuntos de fios):

• Barramento de endereços: a CPU informa qual posição de memória quer acessar.
• Barramento de dados: os bytes viajam por ele, nos dois sentidos.
• Barramento de controle: sinais que dizem se a operação é leitura ou escrita, além de sincronização.

Nos computadores atuais a realidade é mais sofisticada: o controlador de memória fica dentro da própria CPU e fala diretamente com os módulos DDR4/DDR5 por canais dedicados; os núcleos se comunicam entre si por uma rede interna; e dispositivos como SSDs NVMe, placas de vídeo e placas de rede ficam no barramento PCIe. Muitos dispositivos usam DMA (Direct Memory Access) para copiar dados direto para a RAM sem ocupar a CPU. Os drivers que controlam tudo isso, aliás, são escritos quase sempre em C.

Quando dizemos que uma CPU é "de 64 bits", queremos dizer que seus registradores de uso geral têm 64 bits e que ela trabalha com endereços de 64 bits. (Na prática, os processadores x86-64 atuais usam 48 bits do endereço virtual, ou 57 bits com a paginação de 5 níveis, ainda assim, muito mais memória do que qualquer computador tem.)

Localidade: por que a ordem dos seus loops importa

As caches funcionam porque programas costumam ter localidade:

• Localidade temporal: um dado usado agora provavelmente será usado de novo em breve (a variável de um loop, por exemplo).
• Localidade espacial: se você usou o endereço X, provavelmente vai usar X+1, X+2... em seguida (percorrer um array, por exemplo).

Em C, uma matriz int m[N][N] é guardada linha por linha na memória (row-major): toda a linha 0, depois toda a linha 1, e assim por diante. Percorrer a matriz linha a linha lê bytes vizinhos; percorrer coluna a coluna salta N * 4 bytes a cada acesso, desperdiçando quase toda linha de cache trazida da RAM. Veja na prática:

#include <stdio.h>
#include <time.h>
 
#define N 4096
 
static int matriz[N][N]; /* 4096 x 4096 x 4 bytes = 64 MiB */
 
int main(void) {
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            matriz[i][j] = i + j;
 
    long long soma = 0;
    clock_t inicio = clock();
    for (int i = 0; i < N; i++)        /* linha a linha: acesso sequencial */
        for (int j = 0; j < N; j++)
            soma += matriz[i][j];
    double t1 = (double)(clock() - inicio) / CLOCKS_PER_SEC;
 
    inicio = clock();
    for (int j = 0; j < N; j++)        /* coluna a coluna: saltos de 16 KiB */
        for (int i = 0; i < N; i++)
            soma += matriz[i][j];
    double t2 = (double)(clock() - inicio) / CLOCKS_PER_SEC;
 
    printf("linha a linha:   %.3f s\n", t1);
    printf("coluna a coluna: %.3f s\n", t2);
    printf("soma = %lld\n", soma);
    return 0;
}

Numa máquina de teste (x86-64, GCC 16, compilado com -O2), o resultado foi:

linha a linha:   0.004 s
coluna a coluna: 0.053 s
soma = 137405399040

As duas metades fazem exatamente as mesmas somas, mas a segunda foi mais de 10 vezes mais lenta, só por causa da ordem de acesso à memória. Os números exatos vão variar no seu computador, mas a diferença costuma ser grande. Não se preocupe se ainda não entende todo o código: static, clock() e printf serão explicados adiante. O que importa agora é a ideia: em C, você controla o layout e a ordem de acesso aos dados, e o hardware recompensa (ou pune) essas escolhas.

3. Bits, bytes e representação de números

Tudo na memória de um computador é uma sequência de bits. Números, textos, imagens e o próprio programa são só interpretações diferentes desses bits. Em C, é o tipo de uma variável que diz ao compilador como interpretar os bits que ela ocupa. Por isso vale a pena entender como cada tipo de dado é codificado.

Bit, byte, nibble e palavra

• Bit: um dígito binário, 0 ou 1.
• Nibble: 4 bits. Exatamente um dígito hexadecimal.
• Byte: 8 bits. É a menor unidade endereçável da memória: cada byte tem seu próprio endereço. (Em C, o número de bits de um byte é CHAR_BIT, que vale 8 em todas as plataformas comuns.)
• Palavra (word): o tamanho "natural" com que a CPU trabalha. Em uma máquina de 64 bits, 8 bytes. Cuidado: na documentação da Intel, por motivos históricos, word significa 16 bits.

Com n bits, dá para representar 2^n combinações diferentes:

Uma nota sobre unidades, que confunde muita gente: KB (quilobyte) no Sistema Internacional vale 1000 bytes, enquanto KiB (kibibyte) vale 1024 bytes. O mesmo vale para MB/MiB (10^6 contra 2^20), GB/GiB e TB/TiB. Memória RAM é sempre medida em potências de 2; fabricantes de discos usam potências de 10. Por isso um SSD de "1 TB" (10^12 bytes) aparece no Windows com cerca de 931 "GB", o Windows mostra a sigla GB, mas calcula em GiB.

Sistemas de numeração: decimal, binário, hexadecimal e octal

Todo sistema posicional funciona igual: cada posição vale a base elevada a um expoente. No decimal (base 10), 345 = 3×10² + 4×10¹ + 5×10⁰. No binário (base 2), cada posição vale uma potência de 2:

O componente acima mostra cada bit com o seu peso posicional. Os bits ligados valem 32, 8 e 2; somando, 42. É assim que a CPU guarda o número 42 em um byte.

Como escrever 32 ou 64 zeros e uns é impraticável, programadores usam hexadecimal (base 16), com os dígitos 0–9 e A–F. A grande vantagem: cada dígito hexadecimal corresponde a exatamente 4 bits, então a conversão é imediata.

O octal (base 8) agrupa bits de 3 em 3. Hoje ele aparece quase só nas permissões de arquivos do Unix (chmod 755) e em uma pegadinha clássica de C que veremos já já.

Convertendo entre bases passo a passo

Binário para decimal: some os pesos dos bits ligados. 1101 0110 = 128 + 64 + 16 + 4 + 2 = 214.

Decimal para binário: divida sucessivamente por 2 e leia os restos de baixo para cima. Para 42:

42 ÷ 2 = 21  resto 0   ↑
21 ÷ 2 = 10  resto 1   │
10 ÷ 2 =  5  resto 0   │  lendo de baixo para cima:
 5 ÷ 2 =  2  resto 1   │  101010
 2 ÷ 2 =  1  resto 0   │
 1 ÷ 2 =  0  resto 1   │

Binário para hexadecimal: agrupe de 4 em 4 bits, a partir da direita, e troque cada grupo pelo dígito da tabela. 1101 0110 → D 6 → 0xD6. Se faltar bit no último grupo, complete com zeros à esquerda: 10 1010 → 0010 1010 → 0x2A.

Hexadecimal para decimal: multiplique cada dígito pela potência de 16 da sua posição. 0x2A = 2×16 + 10 = 42. 0xFF = 15×16 + 15 = 255. 0x7FFFFFFF é o maior int de 32 bits: 2.147.483.647.

Em C, os prefixos dizem a base de um literal. Os quatro valores abaixo são o mesmo número:

int a = 42;        /* decimal */
int b = 0x2A;      /* hexadecimal: prefixo 0x */
int c = 052;       /* octal: prefixo 0 (zero)! */
int d = 0b101010;  /* binário: padrão no C23; extensão do GCC antes disso */

O programa a seguir imprime um número em várias bases. Como o especificador %b do printf só existe a partir do C23 (e depende da biblioteca C), escrevemos nossa própria função para imprimir em binário:

#include <stdio.h>
 
/* imprime os 'largura' bits menos significativos de 'valor' */
static void imprimir_binario(unsigned valor, int largura) {
    for (int i = largura - 1; i >= 0; i--) {
        putchar(((valor >> i) & 1u) ? '1' : '0');
        if (i % 4 == 0 && i != 0)
            putchar(' ');
    }
    putchar('\n');
}
 
int main(void) {
    int n = 42;
    printf("decimal: %d\n", n);
    printf("hexa:    %x (ou %#X)\n", n, n);
    printf("octal:   %o\n", n);
    printf("binário: ");
    imprimir_binario((unsigned)n, 8);
    printf("%d %d %d\n", 0x2A, 052, 42); /* três jeitos de escrever 42 */
    return 0;
}

decimal: 42
hexa:    2a (ou 0X2A)
octal:   52
binário: 0010 1010
42 42 42

Inteiros sem sinal (unsigned)

Um inteiro sem sinal usa todos os bits para a magnitude. Com n bits, ele vai de 0 a 2^n − 1. Um unsigned char (8 bits) vai de 0 a 255; um unsigned int de 32 bits vai de 0 a 4.294.967.295.

Complemento de dois: como o computador guarda negativos

E os números negativos? A primeira ideia seria reservar um bit para o sinal (sinal e magnitude), mas isso cria dois zeros (+0 e −0) e exige circuitos diferentes para somar e subtrair. Todas as CPUs modernas usam outra representação: o complemento de dois.

A regra é elegante: o bit mais significativo tem peso negativo. Em 8 bits, os pesos são −128, 64, 32, 16, 8, 4, 2 e 1. Assim, um inteiro de 8 bits com sinal vai de −128 a +127.

Para obter o negativo de um número, inverta todos os bits e some 1. Vamos calcular −5 passo a passo:

 5 em binário .......... 0000 0101
 inverte os bits ....... 1111 1010
 soma 1 ................ 1111 1011   ← este é o -5

Confira pelos pesos: −128 + 64 + 32 + 16 + 8 + 2 + 1 = −5. Funciona!

Por que funciona? Um registrador de 8 bits faz contas módulo 256: quando uma soma passa de 255, o vai-um do nono bit simplesmente se perde. Nesse mundo circular, somar 251 é o mesmo que subtrair 5, porque 251 + 5 = 256 ≡ 0. Então faz sentido representar −5 pelo padrão de bits de 251 (que é 1111 1011). E inverter os bits de x resulta em 255 − x; somando 1, temos 256 − x, que é justamente −x módulo 256. Veja a prova com a soma 5 + (−5):

    0000 0101    (+5)
  + 1111 1011    (-5)
  ───────────
  1 0000 0000    → o 9º bit é descartado: resultado 0

A consequência mais bonita: o mesmo circuito somador serve para números com e sem sinal. A CPU não sabe se os bits representam 251 ou −5; quem decide a interpretação é o tipo que você declarou no C.

Alguns padrões que vale memorizar:

Repare na assimetria: existe −128, mas não existe +128 em 8 bits. Por isso negar o menor valor possível (-INT_MIN, por exemplo) estoura o tipo.

Quando um valor com sinal é convertido para um tipo maior, o bit de sinal é replicado à esquerda (extensão de sinal), preservando o valor:

Até o C17, o padrão tecnicamente permitia outras representações (sinal e magnitude, complemento de um), embora na prática todo hardware relevante usasse complemento de dois. O C23 passou a exigir complemento de dois. O programa abaixo mostra os mesmos bits interpretados de duas formas:

#include <stdio.h>
 
int main(void) {
    signed char s = -5;
    unsigned char u = (unsigned char)s; /* mesmos 8 bits, outra leitura */
    printf("s = %d, u = %d\n", s, u);
 
    unsigned char c = 255;
    c = c + 1; /* sem sinal: "dá a volta" de forma bem definida */
    printf("255 + 1 em unsigned char = %d\n", c);
    return 0;
}

s = -5, u = 251
255 + 1 em unsigned char = 0

Overflow: quando o número não cabe

Overflow (estouro) acontece quando o resultado de uma operação não cabe no tipo. Em C, as regras são diferentes para os dois mundos:

• Sem sinal (unsigned): o comportamento é bem definido. O resultado "dá a volta" módulo 2^n: UINT_MAX + 1u vale 0, e 0u - 1u vale UINT_MAX. Isso é útil em hashes, checksums e contadores circulares.
• Com sinal (int, long...): o overflow é comportamento indefinido (undefined behavior, UB). O padrão não diz o que acontece. Na prática o hardware x86-64 daria a volta, mas o compilador assume que overflow com sinal nunca acontece e otimiza o código com base nisso, o que pode produzir resultados absurdos. A seção 24 mostra um exemplo real.

A forma segura é verificar antes de fazer a conta:

#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
 
/* devolve true se a + b cabe em um int */
static bool soma_cabe(int a, int b) {
    if (b > 0 && a > INT_MAX - b) return false; /* estouraria para cima */
    if (b < 0 && a < INT_MIN - b) return false; /* estouraria para baixo */
    return true;
}
 
int main(void) {
    unsigned int u = UINT_MAX;
    u = u + 1u; /* bem definido: vira 0 */
    printf("UINT_MAX + 1 = %u\n", u);
 
    if (soma_cabe(INT_MAX, 1))
        printf("cabe\n");
    else
        printf("INT_MAX + 1 estouraria o int!\n");
    return 0;
}

UINT_MAX + 1 = 0
INT_MAX + 1 estouraria o int!

O GCC e o Clang também oferecem __builtin_add_overflow(a, b, &resultado), e o C23 padronizou essa ideia no cabeçalho <stdckdint.h>, com ckd_add, ckd_sub e ckd_mul.

Ponto flutuante: o padrão IEEE 754

Números com parte fracionária (os tipos float e double) seguem o padrão IEEE 754, uma espécie de notação científica em base 2. O valor é dividido em três campos:

Para números normais, o valor é (−1)^sinal × 1,mantissa × 2^(expoente − viés). O "1," na frente é implícito (não é armazenado), o que dá um bit de precisão de graça.

Vamos codificar 5,75 como float, passo a passo:

1. Parte inteira: 5 = 101. Parte fracionária: 0,75 = 0,5 + 0,25 = 0,11 em binário. Logo 5,75 = 101,11₂.
2. Normalize (mova a vírgula até sobrar um único 1 à esquerda): 101,11₂ = 1,0111₂ × 2².
3. Sinal: positivo → 0.
4. Expoente: 2 + 127 (viés) = 129 = 1000 0001.
5. Mantissa: os bits depois da vírgula, 0111, completados com zeros até 23 bits.

sinal  expoente   mantissa
  0    10000001   01110000000000000000000   = 0x40B80000

Você pode conferir no seu computador, copiando os bytes do float para um inteiro (memcpy e os macros de <inttypes.h> são explicados mais adiante):

#include <inttypes.h>
#include <stdio.h>
#include <string.h>
 
int main(void) {
    float f = 5.75f;
    uint32_t bits;
    memcpy(&bits, &f, sizeof bits); /* copia os 4 bytes do float */
 
    uint32_t sinal = bits >> 31;
    uint32_t expoente = (bits >> 23) & 0xFFu;
    uint32_t mantissa = bits & 0x7FFFFFu;
 
    printf("bits     = 0x%08" PRIX32 "\n", bits);
    printf("sinal    = %" PRIu32 "\n", sinal);
    printf("expoente = %" PRIu32 " (real: %d)\n", expoente, (int)expoente - 127);
    printf("mantissa = 0x%06" PRIX32 "\n", mantissa);
    return 0;
}

bits     = 0x40B80000
sinal    = 0
expoente = 129 (real: 2)
mantissa = 0x380000

Por que 0.1 + 0.2 != 0.3? Porque 0,1 não tem representação exata em binário. Assim como 1/3 vira 0,3333... em decimal, 0,1 vira 0,000110011001100110011...₂, uma dízima infinita. O computador guarda a aproximação mais próxima que cabe na mantissa, e os pequenos erros de arredondamento se somam:

#include <math.h>
#include <stdio.h>
 
int main(void) {
    double a = 0.1 + 0.2;
    printf("%.17f\n", a);
    printf("a == 0.3? %s\n", a == 0.3 ? "sim" : "não");
    printf("quase igual? %s\n", fabs(a - 0.3) < 1e-9 ? "sim" : "não");
    return 0;
}

0.30000000000000004
a == 0.3? não
quase igual? sim

Regras práticas que decorrem disso:

• Nunca compare números de ponto flutuante com ==. Compare a diferença com uma tolerância adequada ao problema.
• Nunca use float/double para dinheiro. Guarde centavos em um inteiro (long long centavos).
• Prefira double a float, a menos que memória ou vazão sejam críticas (gráficos, aprendizado de máquina, microcontroladores sem unidade de double).
• O IEEE 754 tem valores especiais: +inf e -inf (por exemplo, 1.0 / 0.0), NaN (not a number, por exemplo 0.0 / 0.0 ou sqrt(-1.0)) e até -0.0. Um NaN é diferente de tudo, inclusive de si mesmo.

No Linux, programas que usam funções de <math.h> (como fabs e sqrt) precisam da flag -lm na hora de ligar. Veremos isso na seção de flags do GCC.

Caracteres: ASCII e UTF-8

Para o computador, um caractere é só um número. A tabela ASCII (1963) define 128 códigos de 7 bits:

Duas consequências úteis em C: '7' - '0' vale 7 (converte um dígito em número), e letras maiúsculas e minúsculas diferem em um único bit (o de valor 32):

Mesmo assim, use toupper e tolower de <ctype.h> em vez de truques com bits: o código fica mais claro.

ASCII não tem acentos. O padrão universal hoje é o Unicode, que atribui um número (code point) a cada caractere de todos os idiomas, de U+0000 a U+10FFFF. A codificação dominante é a UTF-8, que usa de 1 a 4 bytes por caractere e é compatível com ASCII:

Em C, char é um byte, não um "caractere" no sentido humano. Com o código-fonte salvo em UTF-8, strlen("Olá") devolve 4, não 3:

#include <stdio.h>
#include <string.h>
 
int main(void) {
    const char *palavra = "Olá"; /* arquivo salvo em UTF-8 */
    size_t n = strlen(palavra);
    printf("strlen = %zu\n", n);
    for (size_t i = 0; i < n; i++)
        printf("%02X ", (unsigned char)palavra[i]);
    putchar('\n');
    return 0;
}

strlen = 4
4F 6C C3 A1

Endianness: a ordem dos bytes na memória

Um int de 4 bytes ocupa 4 endereços consecutivos. Mas em que ordem os bytes são guardados? Existem duas convenções:

• Little-endian: o byte menos significativo fica no menor endereço. É o caso do x86-64 e, na prática, do ARM64 em Linux, macOS, Windows, Android e iOS.
• Big-endian: o byte mais significativo fica no menor endereço. É a "ordem de rede" (network byte order) usada em protocolos como TCP/IP, e aparece em algumas arquiteturas mais antigas ou embarcadas.

Veja o valor 0x12345678 guardado a partir do endereço 0x1000:

endereço:        0x1000   0x1001   0x1002   0x1003
                ┌────────┬────────┬────────┬────────┐
little-endian:  │   78   │   56   │   34   │   12   │   (x86-64, ARM64)
                ├────────┼────────┼────────┼────────┤
big-endian:     │   12   │   34   │   56   │   78   │   (ordem de rede)
                └────────┴────────┴────────┴────────┘

Dá para descobrir a ordem da sua máquina olhando o int byte a byte (a sintaxe &x e o * serão explicados na seção de ponteiros):

#include <stdint.h>
#include <stdio.h>
 
int main(void) {
    uint32_t x = 0x12345678;
    unsigned char *bytes = (unsigned char *)&x; /* vê o int byte a byte */
 
    for (size_t i = 0; i < sizeof x; i++)
        printf("byte %zu: %02X\n", i, bytes[i]);
 
    puts(bytes[0] == 0x78 ? "little-endian" : "big-endian");
    return 0;
}

byte 0: 78
byte 1: 56
byte 2: 34
byte 3: 12
little-endian

A ordem dos bytes só importa quando os bytes saem da sua máquina ou são lidos "crus": ao gravar arquivos binários, ao implementar protocolos de rede (em sistemas POSIX, as funções htonl e ntohl convertem para a ordem de rede e de volta) ou ao inspecionar memória no depurador.

4. Memória e endereços

Esta é a seção mais importante para entender ponteiros. Se ela ficar clara, o resto de C fica muito mais fácil.

A memória como um gigantesco array de bytes

Do ponto de vista de um programa, a memória é um array enorme de bytes, em que cada byte tem um número: o seu endereço. Em um processo de 64 bits, os endereços são números de 64 bits, normalmente escritos em hexadecimal (0x7ffc1000, por exemplo).

Uma variável é uma região de bytes consecutivos, e o endereço da variável é o endereço do seu primeiro byte. Veja duas variáveis na memória:

endereço      conteúdo (1 byte por linha)
0x7ffc1000    2A  ┐
0x7ffc1001    00  │  int x = 42;   ocupa 4 bytes (little-endian)
0x7ffc1002    00  │  o endereço de x (&x) é 0x7ffc1000
0x7ffc1003    00  ┘
0x7ffc1004    41  ─  char c = 'A'; ocupa 1 byte em 0x7ffc1004

Repare que o int começa em um endereço múltiplo de 4. Isso se chama alinhamento: a CPU acessa dados alinhados de forma mais eficiente (e algumas arquiteturas nem aceitam acessos desalinhados), então o compilador posiciona cada tipo em endereços múltiplos do seu alinhamento, normalmente o próprio tamanho: 4 para int, 8 para double e ponteiros. Voltaremos a isso ao falar de struct.

Memória virtual, páginas e a MMU

Os endereços que seu programa enxerga não são endereços físicos da RAM. Cada processo recebe o seu próprio espaço de endereçamento virtual, como se tivesse a memória inteira só para si. Quem faz a tradução é a MMU (Memory Management Unit), um circuito dentro da CPU que, a cada acesso, converte o endereço virtual em físico.

A tradução é feita em blocos chamados páginas, tipicamente de 4 KiB no x86-64 (o macOS em Apple Silicon usa páginas de 16 KiB). O sistema operacional mantém, para cada processo, tabelas de páginas que dizem em qual quadro da RAM física cada página virtual está e com quais permissões. Como consultar essas tabelas é caro, a CPU guarda as traduções recentes em uma cache especial, a TLB.

 Processo A (virtual)            RAM (física)            Processo B (virtual)
 0x401000 (código de A) ──MMU──▶ quadro 17
                                 quadro 42  ◀──MMU── 0x401000 (código de B)
 0x7f10a000 (libc)      ──MMU──▶ quadro 3   ◀──MMU── 0x7f55c000 (libc)

O mesmo endereço virtual (0x401000) leva a quadros físicos diferentes em cada processo, enquanto a biblioteca C pode ocupar um único quadro físico compartilhado. Esse mecanismo traz vários benefícios:

• Isolamento: um processo não consegue ler nem escrever na memória de outro.
• Proteção: cada página tem permissões. O código é somente leitura e execução; os dados são leitura e escrita, mas não execução.
• Alocação preguiçosa: uma página só ganha memória física quando é tocada pela primeira vez.
• Swap: páginas pouco usadas podem ir para o disco.
• Compartilhamento: bibliotecas usadas por vários processos ocupam a RAM uma vez só.
• ASLR (Address Space Layout Randomization): o sistema sorteia as posições das regiões a cada execução, dificultando ataques.

Quando um programa acessa um endereço que não está mapeado, ou viola uma permissão (escrever no código, por exemplo), a CPU gera uma exceção que o sistema operacional trata encerrando o processo. No Linux e no macOS você vê o famoso Segmentation fault (sinal SIGSEGV); no Windows, uma violação de acesso (código 0xC0000005).

O layout de memória de um processo

Dentro do espaço virtual, um processo é organizado em regiões com funções bem definidas. O desenho clássico, que corresponde ao Linux x86-64, é este:

 endereços altos
┌────────────────────────────────┐
│ kernel (inacessível)           │
├────────────────────────────────┤
│ pilha (stack)                  │  variáveis locais, endereços de retorno
│   ↓ cresce para baixo          │
│                                │
│         espaço livre           │
│                                │
│ mapeamentos (mmap)             │  bibliotecas compartilhadas (libc),
│                                │  blocos grandes de malloc
│   ↑ cresce para cima           │
│ heap                           │  malloc, calloc, realloc
├────────────────────────────────┤
│ .bss                           │  globais e static sem inicializador (zeradas)
├────────────────────────────────┤
│ .data                          │  globais e static inicializadas
├────────────────────────────────┤
│ .rodata                        │  literais de string e constantes
├────────────────────────────────┤
│ .text                          │  código de máquina (leitura + execução)
└────────────────────────────────┘
 endereços baixos

Um detalhe interessante: a .bss não ocupa espaço no arquivo executável. O arquivo só registra "preciso de N bytes zerados", e o sistema os fornece ao carregar o programa. Por isso um static int tabela[1000000]; não aumenta o executável em 4 MB.

Você pode ver essas regiões com um programa que imprime endereços (o especificador %p imprime ponteiros):

#include <stdio.h>
#include <stdlib.h>
 
int global_iniciada = 42;   /* .data */
int global_zerada;          /* .bss  */
const char *literal = "oi"; /* o texto "oi" fica em .rodata */
 
int main(void) {
    int local = 7;                             /* pilha */
    int *dinamico = malloc(sizeof *dinamico);  /* heap  */
    if (dinamico == NULL)
        return 1;
 
    printf("rodata (literal)        : %p\n", (void *)literal);
    printf("data   (global_iniciada): %p\n", (void *)&global_iniciada);
    printf("bss    (global_zerada)  : %p\n", (void *)&global_zerada);
    printf("heap   (malloc)         : %p\n", (void *)dinamico);
    printf("pilha  (local)          : %p\n", (void *)&local);
 
    free(dinamico);
    return 0;
}

Um exemplo de saída no Linux x86-64 (os valores mudam a cada execução por causa do ASLR):

rodata (literal)        : 0x55d4a6a9c004
data   (global_iniciada): 0x55d4a6a9e010
bss    (global_zerada)  : 0x55d4a6a9e01c
heap   (malloc)         : 0x55d4a7e5c2a0
pilha  (local)          : 0x7ffc8a1e3b54

Os endereços crescem na ordem do desenho: .rodata, .data, .bss, heap e, lá no alto, a pilha. No Windows as mesmas regiões existem, mas o sistema as posiciona em outra ordem e o %p imprime o endereço sem o prefixo 0x.

A pilha (stack) e os stack frames

A pilha é a região usada para controlar chamadas de função. Cada chamada ganha um bloco na pilha, o stack frame (quadro de pilha), com:

• o endereço de retorno (para onde voltar quando a função terminar);
• registradores que a função precisa preservar (por exemplo, o rbp de quem a chamou);
• as variáveis locais da função;
• argumentos que não couberam nos registradores.

Um registrador especial, o ponteiro de pilha (rsp no x86-64, sp no ARM64), aponta para o topo da pilha. No x86-64 a pilha cresce para endereços menores: chamar uma função subtrai de rsp, retornar soma de volta.

 endereços altos
┌──────────────────────────────┐
│ frame de main                │
│   int resultado              │
├──────────────────────────────┤
│ endereço de retorno em main  │ ← empilhado pela instrução call
│ rbp salvo de main            │
│ frame de soma                │
│   int a = 2, int b = 3       │
├──────────────────────────────┤ ← rsp (topo da pilha)
│ (livre)                      │
 endereços baixos

Duas consequências fundamentais:

1. Alocar na pilha é praticamente gratuito: basta mover o rsp. Por isso variáveis locais são tão rápidas.
2. Quando a função retorna, o frame dela deixa de existir. Os bytes continuam lá até serem sobrescritos pela próxima chamada, mas não pertencem mais a ninguém. Guardar o endereço de uma variável local e usá-lo depois que a função retornou é um erro grave (veremos na seção de ponteiros).

A pilha é pequena: em geral 8 MiB para a thread principal no Linux (confira com ulimit -s) e 1 MiB por padrão no Windows (o valor padrão do linker da Microsoft). Arrays grandes não devem ser variáveis locais, use malloc ou static.

O que é um ponteiro, no nível do hardware

Com esse modelo em mente, a definição de ponteiro fica simples: um ponteiro é uma variável cujo valor é um endereço de memória. Em plataformas de 64 bits, todo ponteiro ocupa 8 bytes, não importa para que tipo ele aponte (em 32 bits, 4 bytes).

nome   endereço       conteúdo
x      0x7ffc1000     42               (int, 4 bytes)
p      0x7ffc1008     0x7ffc1000       (int *, 8 bytes) ──▶ aponta para x

No nível da máquina, não há diferença entre um ponteiro e um inteiro: ambos são 64 bits em um registrador. A diferença está no uso: o valor de um ponteiro é usado como endereço por instruções de leitura e escrita. A linha y = *p; vira algo como mov eax, DWORD PTR [rax], que significa "leia 4 bytes a partir do endereço que está em rax".

E o tipo do ponteiro (int *, double *, char *)? Ele só existe para o compilador: diz quantos bytes ler ou escrever no endereço, como interpretar esses bytes e de quanto em quanto avançar na aritmética de ponteiros. Guarde essa frase; ela explica praticamente todo o comportamento de ponteiros que veremos na seção 17.

5. Instalando o GCC no Windows, macOS e Linux

O GCC (GNU Compiler Collection) é o compilador C mais usado do mundo do software livre. Outra opção popular é o Clang, do projeto LLVM, que aceita quase todas as mesmas flags. Escolha o seu sistema nas abas abaixo, a escolha fica lembrada no restante da página.

wsl --install

sudo apt update
sudo apt install build-essential gdb valgrind

sudo apt update
sudo apt install build-essential gdb valgrind

sudo dnf install gcc make gdb valgrind

sudo pacman -S --needed base-devel gdb valgrind

Conferindo a instalação

Em qualquer sistema, gcc --version deve imprimir a versão do compilador. Um exemplo (o texto entre parênteses e o número da versão variam conforme o sistema e a distribuição):

gcc.exe (x86_64-posix-seh-rev0, Built by MinGW-Builds project) 16.1.0
Copyright (C) 2026 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Se aparecer "comando não encontrado" (ou "não é reconhecido como nome de cmdlet" no PowerShell), o diretório do compilador não está no PATH: revise o passo correspondente e abra um terminal novo.

Editor: VS Code com a extensão C/C++

Qualquer editor serve, mas o VS Code com a extensão C/C++ da Microsoft é uma combinação excelente e gratuita: realce de sintaxe, autocompletar (IntelliSense), navegação pelo código e integração com depuradores (GDB no Windows e Linux, LLDB no macOS). Instale a extensão pelo painel de extensões (Ctrl + Shift + X) procurando por "C/C++".

Uma dica: aprenda a compilar pelo terminal antes de depender de botões do editor. Entender o comando gcc que roda por trás é metade do aprendizado, e é isso que faremos a seguir.

6. Seu primeiro programa em C

Crie uma pasta para seus estudos, abra-a no editor e salve o arquivo abaixo como ola.c (com codificação UTF-8):

#include <stdio.h>
 
int main(void) {
    printf("Olá, mundo!\n");
    return 0;
}

O programa linha por linha

• #include <stdio.h>, uma diretiva do pré-processador (tudo que começa com #). Ela copia para o seu arquivo o conteúdo do cabeçalho stdio.h (standard input/output), que declara funções de entrada e saída como printf. Sem essa declaração, o compilador não saberia que printf existe nem que argumentos ela recebe.
• int main(void), a função main é o ponto de entrada: é por ela que seu código começa a executar. O int antes do nome diz que ela devolve um número inteiro para o sistema operacional. O void entre parênteses diz que ela não recebe parâmetros (a versão com argumentos de linha de comando, int main(int argc, char *argv[]), aparece na seção 13).
• { e }, delimitam um bloco: o corpo da função.
• printf("Olá, mundo!\n");, chama a função printf passando um literal de string. O \n é uma sequência de escape que representa a quebra de linha. O ; termina a instrução, em C, praticamente toda instrução termina em ponto e vírgula.
• return 0;, encerra main e devolve 0 ao sistema operacional, que por convenção significa "tudo certo". Qualquer outro valor indica erro. (Desde o C99, chegar ao fim de main sem return equivale a return 0;, mas escrever explicitamente é mais claro.)

C diferencia maiúsculas de minúsculas: Main, PRINTF ou Printf não funcionam. Espaços e quebras de linha, por outro lado, são livres; a indentação serve só para humanos.

Compilando e executando em cada sistema

gcc -std=c17 -Wall -Wextra -o ola.exe ola.c
.\ola.exe

gcc -std=c17 -Wall -Wextra -o ola ola.c
./ola

gcc -std=c17 -Wall -Wextra -o ola ola.c
./ola

A saída esperada:

Olá, mundo!

Traduzindo o comando: gcc é o compilador; -std=c17 escolhe o padrão C17; -Wall -Wextra ligam os avisos (sempre use!); -o ola define o nome do executável; e ola.c é o arquivo-fonte. Sem -o, o GCC gera a.out no Linux e no macOS e a.exe no Windows.

Códigos de saída (exit codes)

O valor devolvido por main vira o código de saída do processo. Scripts, Makefiles e servidores de integração contínua usam esse número para saber se um programa funcionou. Para vê-lo logo depois de executar um programa:

Troque o return 0; por return 3;, recompile, execute e consulte o código: aparecerá 3. Em sistemas Unix, só os 8 bits menos significativos do valor chegam ao shell (de 0 a 255). No bash, dá para encadear comandos pelo resultado: ./ola && echo "deu certo" só imprime a mensagem se o código for 0.

7. Do código-fonte ao executável

O comando gcc ola.c -o ola parece um passo só, mas o gcc é um driver que coordena quatro programas diferentes, em sequência:

 ola.c   código-fonte C
   │   1. pré-processador (gcc -E): expande #include e #define, remove comentários
   ▼
 ola.i   C "puro", já expandido
   │   2. compilador (gcc -S): traduz C para assembly da ISA de destino
   ▼
 ola.s   assembly (texto)
   │   3. montador (gcc -c): traduz assembly para código de máquina
   ▼
 ola.o   arquivo objeto (código de máquina com "buracos" a preencher)
   │   4. linker (gcc): junta objetos e bibliotecas e resolve os nomes
   ▼
 ola     executável (ola.exe no Windows)

Dá para executar cada etapa separadamente e inspecionar os arquivos intermediários:

gcc -E ola.c -o ola.i   # 1. só pré-processa
gcc -S ola.i -o ola.s   # 2. compila para assembly
gcc -c ola.s -o ola.o   # 3. monta: gera o arquivo objeto
gcc ola.o -o ola        # 4. liga: gera o executável

Ou, de uma vez só, guardando todos os intermediários: gcc -save-temps ola.c -o ola. E gcc -v ola.c -o ola mostra os programas internos que o driver chama (cc1, as, collect2/ld) e os diretórios onde ele procura cabeçalhos e bibliotecas.

Etapa 1: pré-processamento

O pré-processador trabalha só com texto. Ele substitui cada #include pelo conteúdo do arquivo incluído, expande as macros de #define, avalia os #if e remove os comentários. Abra o ola.i: seu programa de 6 linhas virou centenas de linhas, porque o stdio.h (e os cabeçalhos que ele inclui) foram colados ali. Em algum ponto, com a glibc do Linux, você encontra a declaração:

extern int printf (const char *__restrict __format, ...);

É graças a ela que o compilador sabe como chamar printf. As linhas que começam com # 1 "ola.c" são marcadores que ajudam o compilador a reportar erros com o arquivo e a linha originais.

Etapa 2: compilação para assembly

O compilador propriamente dito (no GCC, o programa cc1) analisa o C, verifica tipos, otimiza e gera assembly: uma representação em texto das instruções de máquina. Para ver algo mais interessante que o "olá, mundo", compile esta função:

int soma(int a, int b) {
    return a + b;
}

Com gcc -S -O0 soma.c (sem otimização), o GCC para Linux x86-64 gera o seguinte (diretivas do montador removidas):

soma:
        pushq   %rbp              # salva o rbp de quem chamou na pilha
        movq    %rsp, %rbp        # rbp = topo atual da pilha (início do frame)
        movl    %edi, -4(%rbp)    # copia o 1º argumento (a, em edi) para a pilha
        movl    %esi, -8(%rbp)    # copia o 2º argumento (b, em esi) para a pilha
        movl    -4(%rbp), %edx    # carrega a em edx
        movl    -8(%rbp), %eax    # carrega b em eax
        addl    %edx, %eax        # eax = eax + edx  (a ULA soma)
        popq    %rbp              # restaura o rbp de quem chamou
        ret                       # volta; o resultado fica em eax

Como ler esse assembly (a sintaxe padrão do GCC é a AT&T):

• Registradores começam com % e constantes com $.
• A ordem é origem, destino: movl %edi, -4(%rbp) copia edi para a memória.
• O sufixo diz o tamanho: l = 32 bits (long word), q = 64 bits (quad word).
• -4(%rbp) significa "o endereço rbp − 4": uma posição na pilha.
• Pela convenção de chamada do Linux e do macOS em x86-64 (a System V ABI), os primeiros argumentos inteiros chegam em rdi, rsi, rdx, rcx, r8 e r9, e o valor de retorno volta em rax (eax é a metade de 32 bits de rax). O Windows usa outra convenção: rcx, rdx, r8 e r9.

Sem otimização, o compilador copia tudo para a pilha e lê de volta, porque isso facilita a depuração. Agora com gcc -S -O2 soma.c:

soma:
        leal    (%rdi,%rsi), %eax   # eax = rdi + rsi, em uma instrução
        ret

A função inteira virou uma instrução (mais o retorno). O lea é uma instrução de cálculo de endereço que o compilador usa como um somador rápido. Se você prefere a sintaxe da Intel (destino primeiro, sem %), use -masm=intel. E para experimentar sem instalar nada, o site Compiler Explorer mostra o assembly de qualquer compilador enquanto você digita.

Uma curiosidade: compile o ola.c com -S e procure a chamada a printf. Você vai encontrar call puts. O GCC conhece a biblioteca padrão e percebeu que um printf de uma string fixa terminada em \n equivale a um puts, que é mais simples, e fez a troca mesmo sem otimizações ligadas.

Etapa 3: montagem e arquivos objeto

O montador (assembler, o programa as) traduz o assembly para código de máquina, gerando um arquivo objeto (.o; .obj no compilador da Microsoft). Ele já contém os bytes das instruções, mas ainda tem "buracos": o ola.o chama puts, mas não sabe onde puts vai estar. O comando nm lista os símbolos de um objeto:

nm ola.o

0000000000000000 T main
                 U puts

T significa "definido na seção de código (text)" e U significa "indefinido: alguém precisa fornecer". Para ver as instruções desmontadas, use objdump -d ola.o.

Etapa 4: ligação (linking)

O linker (ld, chamado pelo GCC) junta todos os objetos do programa com as bibliotecas necessárias e com o código de inicialização da biblioteca C, resolve os símbolos (liga cada U puts à definição real de puts) e produz o executável.

Um detalhe que surpreende: main não é a primeira coisa a executar. O linker inclui um código de inicialização (no Linux com glibc, o símbolo _start) que prepara o ambiente, chama main e, quando ela retorna, passa o valor devolvido para a função exit, que encerra o processo com aquele código.

Ligação estática vs dinâmica

Existem duas formas de incluir o código de uma biblioteca no programa:

Para ver de quais bibliotecas dinâmicas um executável depende: ldd ./ola no Linux (e no MSYS2), otool -L ./ola no macOS. No Linux, ligar estaticamente com a glibc exige a versão estática da biblioteca instalada (no Fedora, o pacote glibc-static); no macOS, executáveis totalmente estáticos não são suportados.

Formatos de executável: ELF, PE e Mach-O

Um executável não é só código de máquina: ele tem um cabeçalho que descreve as seções (.text, .data...), onde o programa começa, de quais bibliotecas depende e como carregá-lo na memória. Cada sistema usa um formato:

O comando file identifica o formato. No Linux, file ola responde algo como ola: ELF 64-bit LSB pie executable, x86-64, ...; no macOS com Apple Silicon, ola: Mach-O 64-bit executable arm64. É por isso que um executável compilado no Linux não roda no Windows, mesmo que os dois computadores tenham a mesma CPU: o formato do arquivo, a convenção de chamada e as bibliotecas do sistema são diferentes. O código C é portável; o executável, não.

8. Flags essenciais do GCC

O GCC tem centenas de opções, mas um conjunto pequeno resolve 95% do dia a dia. As mesmas flags funcionam no Clang.

Dois avisos que valem ouro e não estão em -Wall -Wextra: -Wconversion (conversões que podem perder dados, como double para int) e -Wshadow (uma variável local escondendo outra de mesmo nome).

O comando de estimação para o dia a dia

Durante o desenvolvimento, no Linux, no macOS ou no WSL:

gcc -std=c17 -Wall -Wextra -Wpedantic -g -fsanitize=address,undefined programa.c -o programa

No Windows com MSYS2 (onde os sanitizers não estão disponíveis no GCC):

gcc -std=c17 -Wall -Wextra -Wpedantic -g programa.c -o programa.exe

Para a versão final, troque -g e os sanitizers por otimização:

gcc -std=c17 -O2 -Wall -Wextra programa.c -o programa

Trate avisos como erros de verdade. Quase todo aviso do GCC aponta para um bug real ou para um código que vai virar bug depois.

9. Tipos de dados

Em C, toda variável tem um tipo, fixo durante a vida dela. O tipo determina quantos bytes ela ocupa, como esses bytes são interpretados e quais operações são permitidas. Declarar é simples: tipo nome = valor_inicial;.

Inteiros e seus tamanhos

O padrão C não fixa o tamanho dos tipos inteiros; ele define apenas mínimos e uma ordem (char ≤ short ≤ int ≤ long ≤ long long). Cada plataforma escolhe os valores concretos, seguindo um modelo de dados:

Os nomes dos modelos contam a história: no LP64, Long e Pointer têm 64 bits; no LLP64, só Long Long e Pointer. A diferença no long é uma fonte clássica de bugs em código que precisa rodar nos dois sistemas: não use long quando precisar de exatamente 64 bits, use long long ou int64_t. (O long double é ainda mais variável, de 8 a 16 bytes conforme o sistema e o compilador; evite depender dele.)

Todos os inteiros existem em versão com sinal (o padrão) e sem sinal (unsigned int, unsigned long...). Descubra os tamanhos da sua máquina:

#include <limits.h>
#include <stdio.h>
 
int main(void) {
    printf("char:      %zu byte(s)\n", sizeof(char));
    printf("short:     %zu\n", sizeof(short));
    printf("int:       %zu\n", sizeof(int));
    printf("long:      %zu\n", sizeof(long));
    printf("long long: %zu\n", sizeof(long long));
    printf("double:    %zu\n", sizeof(double));
    printf("ponteiro:  %zu\n", sizeof(void *));
    printf("INT_MAX:   %d\n", INT_MAX);
    printf("LLONG_MAX: %lld\n", LLONG_MAX);
    printf("CHAR_MIN:  %d\n", CHAR_MIN);
    return 0;
}

Saída no Linux x86-64 (no Windows, a única diferença é long: 4):

char:      1 byte(s)
short:     2
int:       4
long:      8
long long: 8
double:    8
ponteiro:  8
INT_MAX:   2147483647
LLONG_MAX: 9223372036854775807
CHAR_MIN:  -128

char e o mistério do sinal

char, signed char e unsigned char são três tipos diferentes. Se o char "puro" tem sinal ou não é uma escolha da plataforma (implementation-defined): ele tem sinal no x86-64 (Linux, Windows e macOS) e também nos Macs com Apple Silicon, mas não tem sinal no Linux em ARM64, por exemplo. O CHAR_MIN: -128 acima mostra que, naquela máquina, char tem sinal.

Regras práticas:

• Para texto, use char.
• Para bytes crus (arquivos binários, buffers de rede), use unsigned char ou uint8_t.
• Ao passar um char para as funções de <ctype.h> (isalpha, toupper...), converta para unsigned char: isalpha((unsigned char)c). Passar um char negativo (um byte de UTF-8, por exemplo) para essas funções é comportamento indefinido.

Tipos de largura fixa: stdint.h

Quando o tamanho importa (formatos de arquivo, protocolos, hardware, hashes), use os tipos de <stdint.h> (C99), que têm largura exata:

Para imprimir esses tipos de forma portável, <inttypes.h> oferece macros com o especificador certo para cada plataforma:

#include <inttypes.h>
#include <stdio.h>
 
int main(void) {
    int64_t populacao = 8200000000; /* não cabe em 32 bits */
    uint8_t byte = 255;
    uint32_t mascara = 0xFF00FF00u;
 
    printf("população: %" PRId64 "\n", populacao);
    printf("byte:      %" PRIu8 "\n", byte);
    printf("máscara:   0x%08" PRIX32 "\n", mascara);
    return 0;
}

população: 8200000000
byte:      255
máscara:   0xFF00FF00

O truque é que strings literais vizinhas são concatenadas: "%" PRId64 "\n" vira algo como "%ld\n" no Linux e "%lld\n" no Windows.

size_t e o operador sizeof

sizeof é um operador (não uma função) que devolve o tamanho em bytes de um tipo ou de uma expressão. O resultado tem o tipo size_t: um inteiro sem sinal grande o bastante para representar o tamanho de qualquer objeto (8 bytes em sistemas de 64 bits). Use size_t para tamanhos, comprimentos e índices de arrays, e imprima com %zu.

• Com tipos, os parênteses são obrigatórios: sizeof(int).
• Com expressões, são opcionais: sizeof x ou sizeof(x).
• O valor é calculado em tempo de compilação; a expressão nem é executada (sizeof(i++) não incrementa i).

Para diferenças entre ponteiros existe o tipo com sinal ptrdiff_t, impresso com %td.

Limites: limits.h e float.h

Em vez de decorar números, use as constantes da biblioteca padrão:

bool: de stdbool.h à palavra-chave do C23

O C original não tinha tipo booleano: 0 é falso e qualquer outro valor é verdadeiro. É por isso que if (n) e if (ponteiro) funcionam. O C99 criou o tipo _Bool e o cabeçalho <stdbool.h>, com os apelidos bool, true (1) e false (0). No C23, bool, true e false viraram palavras-chave e o #include deixou de ser necessário (mas continua funcionando).

Converter qualquer valor para bool resulta em true se ele for diferente de zero. Cuidado com a diferença: (bool)0.5 vale true, mas (int)0.5 vale 0.

const

const marca uma variável como somente leitura: o compilador recusa qualquer atribuição a ela depois da inicialização.

const double TAXA = 0.15;
/* TAXA = 0.2;  erro: assignment of read-only variable 'TAXA' */

Uma pegadinha de C (que não existe em C++): uma variável const não é uma constante de compilação. const int TAM = 10; não pode ser usada como rótulo de case nem como tamanho de array global. Para constantes inteiras "de verdade", use enum { TAM = 10 };, #define TAM 10 ou, no C23, constexpr int TAM = 10;. Veremos ainda o const em parâmetros e ponteiros, onde ele documenta que uma função não altera os dados recebidos.

Literais

Um literal é um valor escrito diretamente no código. O tipo dele depende da forma como é escrito:

As sequências de escape mais usadas dentro de literais de caractere e de string:

Literais de string vizinhos são concatenados pelo compilador: "Olá, " "mundo" é o mesmo que "Olá, mundo", útil para quebrar strings longas em várias linhas.

Conversões implícitas e promoção de inteiros

Quando uma expressão mistura tipos, o C converte automaticamente os operandos para um tipo comum. As regras, simplificadas:

1. Promoção de inteiros: tipos menores que int (char, short, bool) viram int antes de qualquer conta.
2. Conversões aritméticas usuais: se um operando é de ponto flutuante, o outro vira ponto flutuante. Senão, o de menor "posto" vira o de maior posto.
3. Com sinal contra sem sinal: se os postos forem iguais (ou o sem sinal for maior), o valor com sinal vira sem sinal.

Essas regras geram algumas das armadilhas mais famosas de C. O programa abaixo demonstra quatro delas, e o GCC, com -Wextra, avisa sobre a comparação da terceira (um aviso proposital, que é justamente o ponto):

#include <stdio.h>
#include <string.h>
 
int main(void) {
    /* 1. divisão inteira: os dois operandos são int */
    double media = 7 / 2;
    printf("7 / 2   = %.1f\n", media);  /* 3.0, não 3.5! */
    printf("7 / 2.0 = %.1f\n", 7 / 2.0); /* 3.5 */
 
    /* 2. promoção: unsigned char vira int antes da conta */
    unsigned char a = 200, b = 100;
    int soma = a + b;                         /* 300, sem estouro */
    unsigned char trunc = (unsigned char)(a + b); /* 300 % 256 = 44 */
    printf("soma = %d, truncado = %d\n", soma, trunc);
 
    /* 3. com sinal x sem sinal: -1 vira UINT_MAX */
    if (-1 > 1u)
        printf("-1 > 1u é verdadeiro!\n");
 
    /* 4. size_t não tem sinal: 0 - 1 dá a volta */
    printf("strlen(\"\") - 1 = %zu\n", strlen("") - 1);
    return 0;
}

7 / 2   = 3.0
7 / 2.0 = 3.5
soma = 300, truncado = 44
-1 > 1u é verdadeiro!
strlen("") - 1 = 18446744073709551615

A quarta armadilha causa bugs reais: um loop como for (size_t i = 0; i < strlen(s) - 1; i++) com uma string vazia vai tentar percorrer 18 quintilhões de posições. Ligue -Wall -Wextra e leia os avisos de comparação entre com e sem sinal com atenção.

Casts explícitos

Um cast força uma conversão: (tipo) expressão. O uso mais comum é evitar a divisão inteira:

int soma = 7, n = 2;
double media = (double)soma / n; /* 3.5: soma vira double antes da divisão */

Três cuidados: converter double para inteiro trunca em direção a zero ((int)-2.7 vale -2); converter um double grande demais para o tipo inteiro é comportamento indefinido; e um cast silencia avisos sem corrigir nada. Use casts para expressar uma intenção, nunca para calar o compilador.

10. Operadores

Aritméticos

Desde o C99, a divisão inteira sempre trunca em direção a zero, e vale a identidade (a / b) * b + a % b == a. O operador % só funciona com inteiros (para double, use fmod de <math.h>). Dividir um inteiro por zero, ou calcular INT_MIN / -1, é comportamento indefinido, normalmente o programa é derrubado.

Relacionais e lógicos

Os operadores relacionais (==, !=, <, >, <=, >=) e lógicos (&&, ||, !) produzem um int que vale 1 (verdadeiro) ou 0 (falso).

Os operadores && e || fazem curto-circuito: o operando da direita só é avaliado se for necessário. Isso é usado o tempo todo como proteção:

if (p != NULL && p->idade >= 18) { /* só acessa p->idade se p não for NULL */ }
if (n == 0 || total / n > 10) { /* nunca divide por zero */ }

Duas armadilhas clássicas (o GCC avisa sobre ambas com -Wall):

• = no lugar de ==: if (x = 5) atribui 5 a x, e a condição fica sempre verdadeira.
• Comparações encadeadas: 0 < x < 10 não significa o que significa na matemática. É avaliado como (0 < x) < 10, ou seja, 0 < 10 ou 1 < 10: sempre verdadeiro. Escreva 0 < x && x < 10.

Operadores bit a bit

Os operadores bit a bit aplicam as portas lógicas da seção 2 a cada par de bits de dois inteiros. Usando a = 12 (1100) e b = 10 (1010):

Deslocar n posições para a esquerda multiplica por 2^n; para a direita, divide (para valores sem sinal):

Regras importantes sobre deslocamentos:

• Faça operações de bits com tipos sem sinal sempre que possível.
• Deslocar por um valor negativo ou maior ou igual à largura do tipo (x << 32 com x de 32 bits) é comportamento indefinido.
• Deslocar um valor com sinal para a esquerda de forma que o resultado não caiba (como 1 << 31 com int de 32 bits) também é. Escreva 1u << 31.
• Deslocar um negativo para a direita é implementation-defined: o GCC replica o bit de sinal (deslocamento aritmético).

Máscaras na prática: ligar, desligar, inverter e testar bits

Uma máscara é um número com bits ligados nas posições que interessam. Com ela, as quatro operações fundamentais sobre o bit n de uma variável x:

O uso mais comum é guardar várias opções liga/desliga (flags) em um único inteiro, exatamente como as permissões rwx do Unix:

#include <stdio.h>
 
enum {
    PERM_LER = 1u << 2,      /* 100 */
    PERM_ESCREVER = 1u << 1, /* 010 */
    PERM_EXECUTAR = 1u << 0, /* 001 */
};
 
static void mostrar(unsigned p) {
    printf("%c%c%c\n",
           (p & PERM_LER) ? 'r' : '-',
           (p & PERM_ESCREVER) ? 'w' : '-',
           (p & PERM_EXECUTAR) ? 'x' : '-');
}
 
int main(void) {
    unsigned perm = PERM_LER | PERM_ESCREVER; /* rw- */
    mostrar(perm);
    perm |= PERM_EXECUTAR;  /* liga o x:    rwx */
    mostrar(perm);
    perm &= ~PERM_ESCREVER; /* desliga o w: r-x */
    mostrar(perm);
    perm ^= PERM_LER;       /* inverte o r: --x */
    mostrar(perm);
    printf("valor final: %u\n", perm);
    return 0;
}

rw-
rwx
r-x
--x
valor final: 1

Incremento e decremento: pré vs pós

++ soma 1 e -- subtrai 1, em duas formas:

int a = 5;
int b = a++; /* pós: b recebe o valor ANTIGO (5); depois a vira 6 */
int c = ++a; /* pré: a vira 7 primeiro; c recebe 7 */

Quando o operador aparece sozinho em uma instrução (i++;, como no for), as duas formas são equivalentes.

Atribuição composta, ternário, vírgula e sizeof

• Atribuição composta: x += 3 equivale a x = x + 3. Existem para todos os operadores binários: -=, *=, /=, %=, &=, |=, ^=, <<=, >>=.
• Ternário: condição ? valor_se_verdadeiro : valor_se_falso é uma expressão (produz um valor), ao contrário do if. Exemplo: const char *palavra = (n == 1) ? "item" : "itens";.
• Vírgula: avalia a expressão da esquerda, descarta o resultado e avalia a da direita. Quase só aparece no for: for (i = 0, j = n - 1; i < j; i++, j--). (As vírgulas que separam argumentos de função não são esse operador.)
• sizeof: além de tamanhos de tipos, calcula o número de elementos de um array: sizeof v / sizeof v[0] (só funciona com arrays de verdade, não com ponteiros, veremos por quê).

Precedência e associatividade

A precedência decide quais operadores "grudam" primeiro. Uma tabela simplificada, da maior para a menor:

As pegadinhas mais comuns:

• x & MASCARA == 0 é lido como x & (MASCARA == 0), porque == tem precedência maior que &. Escreva (x & MASCARA) == 0.
• *p++ é *(p++): incrementa o ponteiro, não o valor apontado. Para incrementar o valor, (*p)++.
• a << 1 + 1 é a << 2, porque + vem antes de <<.

A regra de ouro: na dúvida, use parênteses. Eles não custam nada e deixam a intenção explícita.

Modificações sem sequenciamento (i = i++)

Em C, a ordem de avaliação dos operandos de uma expressão e dos argumentos de uma função, na maioria dos casos, não é especificada. Por isso, modificar uma variável duas vezes na mesma expressão, ou modificá-la e lê-la em outro ponto da mesma expressão, é comportamento indefinido:

i = i++;                     /* UB */
v[i] = i++;                  /* UB */
printf("%d %d\n", i, i++);   /* UB */

O GCC avisa com -Wall (operation on 'i' may be undefined). Não tente adivinhar o resultado: quebre em instruções separadas.

11. Entrada e saída no terminal

As funções de entrada e saída ficam em <stdio.h>. Todo programa C começa com três fluxos (streams) abertos: stdin (entrada, normalmente o teclado), stdout (saída, normalmente o terminal) e stderr (saída de erros, também o terminal). Mensagens de erro devem ir para stderr com fprintf(stderr, ...): assim elas continuam aparecendo mesmo quando a saída normal é redirecionada para um arquivo.

printf e seus especificadores

printf recebe uma string de formato e uma lista de valores. Cada % na string é um especificador que diz como formatar o próximo valor:

Passar um tipo diferente do que o especificador espera (um double para %d, por exemplo) é comportamento indefinido. O GCC confere os formatos literais com -Wall (opção -Wformat): mais um motivo para nunca desligar os avisos.

Largura, precisão e flags

O formato completo de um especificador é %[flags][largura][.precisão]tipo:

Com largura e alinhamento dá para montar tabelas bem alinhadas:

#include <stdio.h>
 
int main(void) {
    const char *produtos[] = {"Coxinha", "Pastel", "Suco"};
    double precos[] = {4.5, 7.25, 9.0};
    int qtd[] = {2, 3, 1};
 
    printf("%-10s %5s %10s\n", "Produto", "Qtd", "Total");
    for (int i = 0; i < 3; i++)
        printf("%-10s %5d %10.2f\n", produtos[i], qtd[i], precos[i] * qtd[i]);
    return 0;
}

Produto      Qtd      Total
Coxinha        2       9.00
Pastel         3      21.75
Suco           1       9.00

Um detalhe: a largura conta bytes, não letras. Uma palavra com acento em UTF-8 tem mais bytes do que letras, e a coluna sai desalinhada.

scanf e suas armadilhas

scanf lê e converte a entrada segundo um formato, e precisa do endereço das variáveis onde vai escrever (o operador &, que veremos em detalhes na seção de ponteiros):

int idade;
printf("Idade: ");
if (scanf("%d", &idade) != 1) {
    fprintf(stderr, "Entrada inválida\n");
}

Ele é prático para exercícios, mas cheio de armadilhas:

1. Esquecer o &: scanf("%d", idade) passa o valor em vez do endereço, e o programa escreve em um lugar aleatório da memória (o GCC avisa).
2. Não conferir o retorno: scanf devolve quantos itens conseguiu converter (ou EOF se a entrada acabou). Se o usuário digita abc onde se esperava um número, nada é lido, o texto continua no buffer e um loop que chama scanf de novo fica girando para sempre.
3. %s sem limite: scanf("%s", nome) escreve quantos bytes o usuário digitar, estourando o array. Sempre informe a largura: scanf("%49s", nome) para um char nome[50]. Além disso, %s para no primeiro espaço.
4. O \n que sobra: depois de scanf("%d", ...), o Enter digitado continua no buffer. Um scanf("%c", &opcao) seguinte lê esse \n. A solução é um espaço antes do %c: scanf(" %c", &opcao) pula espaços e quebras de linha.
5. %lf para double: no scanf, %f é para float e %lf para double (no printf, %f serve para os dois).

Leitura segura com fgets e strtol

Em programas interativos de verdade, a abordagem robusta é ler a linha inteira com fgets e depois converter com strtol (inteiros) ou strtod (ponto flutuante). Assim o buffer de entrada nunca fica em um estado inconsistente e você tem controle total sobre os erros:

#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
/* lê uma linha e converte para int; devolve false se for inválida */
static bool ler_inteiro(const char *mensagem, int *saida) {
    char linha[64];
    printf("%s", mensagem);
    fflush(stdout); /* garante que a mensagem apareça antes da leitura */
    if (fgets(linha, sizeof linha, stdin) == NULL)
        return false; /* fim da entrada ou erro */
 
    char *quebra = strchr(linha, '\n');
    if (quebra != NULL) {
        *quebra = '\0'; /* remove o \n do final */
    } else if (!feof(stdin)) {
        int c; /* linha longa demais: descarta o resto e rejeita */
        while ((c = getchar()) != '\n' && c != EOF) {}
        return false;
    }
 
    char *fim;
    errno = 0;
    long valor = strtol(linha, &fim, 10);
    if (fim == linha || *fim != '\0')
        return false; /* nenhum dígito, ou lixo depois do número */
    if (errno == ERANGE || valor < INT_MIN || valor > INT_MAX)
        return false; /* fora da faixa do int */
    *saida = (int)valor;
    return true;
}
 
int main(void) {
    int idade;
    while (!ler_inteiro("Sua idade: ", &idade)) {
        if (feof(stdin))
            return 1; /* a entrada acabou (Ctrl+D ou Ctrl+Z) */
        puts("Valor inválido, tente de novo.");
    }
    printf("Daqui a 10 anos você terá %d anos.\n", idade + 10);
    return 0;
}