Esta página precisa de um navegador recente (com suporte a SharedArrayBuffer). Por favor, atualize Chrome, Edge, Firefox ou Safari para a versão mais recente.
Todo programa C começa em main. #include <stdio.h> importa um cabeçalho para que você possa usar printf para imprimir. Uma função é um bloco nomeado que pode ser chamado; \n inicia uma nova linha. main retorna 0 para significar "sucesso".
#include <stdio.h>
void greet(void) {
printf("Hello, world!\n");
}
int main(void) {
greet();
printf("I am learning C.\n");
return 0;
}
*Todo programa C executa a partir de main após incluir cabeçalhos
1.2
Variáveis, tipos e aritmética
C precisa de um tipo para cada variável: int (inteiro), double (ponto flutuante), char (um único caractere). printf usa um especificador de formato — %d, %f, %c — para cada valor. / entre dois ints é divisão inteira; % é o resto.
#include <stdio.h>
int main(void) {
int n = 17;
double pi = 3.14;
char grade = 'A';
printf("%d %.2f %c\n", n, pi, grade); // 17 3.14 A
printf("%d %d\n", 7 / 2, 7 % 2); // 3 1
return 0;
}
A string de formato dirige tanto a impressão quanto a leitura:
Especificador
Tipo
Exemplo de saída
%d
int
17
%f
double (%.2f = 2 casas decimais)
3.14
%c
char
A
%s
uma string
Mei
%zu
um tamanho (de sizeof / strlen)
3
%x
unsigned int, impresso em base 16
ff
scanf("%d", &n) lê um int através de seu endereço (note o &). Os formatos de entrada e saída não são idênticos: printf("%f", x) imprime um double, mas scanf("%lf", &x) lê um double; a entrada %f precisa de um float *. Verifique a contagem retornada de itens atribuídos com sucesso. Seu sibling sscanf extrai valores de uma string:
#include <stdio.h>
int main(void) {
char line[] = "Mei 88";
char name[20];
int score;
if (sscanf(line, "%19s %d", name, &score) != 2) return 1;
printf("%s scored %d\n", name, score); // Mei scored 88
return 0;
}
1.3
Comentários e estilo
Um comentário é uma nota para humanos; o compilador o ignora. Use // para uma linha e /* ... */ para um bloco. Boa indentação e nomes claros tornam o código fácil de ler.
#include <stdio.h>
int main(void) {
// a single-line comment
/* a block
comment */
int total = 3 + 4; // clear names help
printf("%d\n", total); // 7
return 0;
}
Erros comuns
Declarações e expressões terminam com ;; um bloco composto { ... } não precisa de ponto e vírgula extra. main deve retornar int (return 0;).
printf precisa de uma string de formato: %d para int, %f para double, e \n para uma nova linha.
Um formato errado como %d para um double causa comportamento indefinido; não é garantido apenas imprimir lixo. Combine o tipo do argumento.
Um if executa um bloco quando uma condição 条件 é verdadeira. C não tem um tipo booleano real 布尔值 por padrão: 0 é falso e qualquer valor não-zero é verdadeiro. Encadeie escolhas com else if e else. Compare com ==, !=, <, >, <=, >=.
#include <stdio.h>
int main(void) {
int score = 72;
if (score >= 90) {
printf("A\n");
} else if (score >= 60) {
printf("Pass\n");
} else {
printf("Fail\n");
}
return 0;
}
*if escolhe o ramo verdadeiro; else o ramo falso
2.2
interruptor
Um switch escolhe um case por um valor inteiro. Cada case precisa de um break para sair 跳出 — sem ele, o C "cai" no próximo caso. default executa quando nada corresponde.
#include <stdio.h>
int main(void) {
int day = 3;
switch (day) {
case 1: printf("Mon\n"); break;
case 2: printf("Tue\n"); break;
case 3: printf("Wed\n"); break;
default: printf("Other\n");
}
return 0;
}
Erros comuns
if (x = 5) atribui e é sempre verdadeiro; use == para comparar.
Cada caso de switch precisa de um break;, ou ele cai para o próximo.
0 é falso e qualquer valor não-zero é verdadeiro em uma condição.
Um laço 循环 repete um bloco. Um laço while roda enquanto uma condição é verdadeira. Um laço for agrupa o início, o teste e o incremento 自增 (i++) em uma linha — melhor quando você sabe quantas vezes repetir.
#include <stdio.h>
int main(void) {
int i = 1;
while (i <= 3) {
printf("%d ", i);
i++;
}
printf("\n"); // 1 2 3
for (int j = 0; j < 5; j++) {
printf("%d ", j);
}
printf("\n"); // 0 1 2 3 4
return 0;
}
*while verifica uma condição; for conta com um passo
3.2
Acumulação
Um padrão comum: comece um acumulador 累加器 em 0, depois adicione a ele dentro de um laço. A mesma ideia conta itens ou encontra um total acumulado.
#include <stdio.h>
int main(void) {
int total = 0;
for (int i = 1; i <= 5; i++) {
total += i; // 1 + 2 + 3 + 4 + 5
}
printf("%d\n", total); // 15
return 0;
}
3.3
Laços aninhados e padrões
Um laço dentro de outro laço é um laço aninhado 嵌套. O laço interno termina completamente para cada etapa do laço externo — perfeito para grades e padrões.
#include <stdio.h>
int main(void) {
for (int row = 0; row < 3; row++) {
for (int col = 0; col < 3; col++) {
printf("*");
}
printf("\n");
}
return 0;
}
Erros comuns
for (i = 0; i < n; i++) executa n vezes; um ponto e vírgula logo após for (...) cria um loop vazio.
Um while cuja condição nunca se torna falsa roda para sempre.
Declare o contador (int i) antes ou no cabeçalho do for.
Uma função recebe parâmetros 参数 (inputs) e devolve um valor de retorno 返回值. O tipo de retorno vem primeiro (int, double, …); void significa que não retorna nada.
#include <stdio.h>
int square(int x) { // x is a parameter
return x * x; // hand back a value
}
int main(void) {
int r = square(5);
printf("%d\n", r); // 25
return 0;
}
Parâmetros entra; valor de retorno sai
4.2
Protótipos e escopo
C lê de cima para baixo, então uma função deve ser conhecida antes de ser chamada. Um protótipo 函数原型 — a linha do cabeçalho mais ; — a declara cedo para que você possa manter main em primeiro lugar. O escopo 作用域 de uma variável é o bloco onde ela existe: ele é local 局部 e desaparece quando o bloco termina.
#include <stdio.h>
int add(int a, int b); // prototype: declared before use
int main(void) {
printf("%d\n", add(3, 4)); // 7
return 0;
}
int add(int a, int b) { // definition comes later
int sum = a + b; // sum is local to add
return sum;
}
Erros comuns
Uma função usada antes de ser definida precisa de um protótipo acima de main.
Os argumentos são passados POR VALOR — alterações dentro de uma função não afetam quem chamou a menos que você passe um ponteiro.
Uma variável declarada dentro de uma função é local a ela.
Uma matriz armazena vários valores de um único tipo. Indexe de 0. C não armazena o comprimento de uma matriz, então uma tática comum calcula a contagem de elementos: sizeof(a) / sizeof(a[0]).
#include <stdio.h>
int main(void) {
int scores[3] = {88, 71, 95};
printf("%d\n", scores[0]); // 88
scores[1] = 100;
printf("%d\n", scores[1]); // 100
int n = sizeof(scores) / sizeof(scores[0]);
printf("%d\n", n); // 3
return 0;
}
As posições do array têm índices começando em 0
5.2
Algoritmos de arrays
Percorra uma matriz com um loop for para encontrar um máximo, um total ou uma contagem. Sempre faça o loop de 0 até n - 1.
#include <stdio.h>
int main(void) {
int a[] = {3, 9, 2, 7};
int n = sizeof(a) / sizeof(a[0]);
int max = a[0], total = 0;
for (int i = 0; i < n; i++) {
if (a[i] > max) max = a[i];
total += a[i];
}
printf("%d %d\n", max, total); // 9 21
return 0;
}
5.3
Arrays 2-D
Uma matriz 2-D é uma grade de linhas e colunas: grid[row][col]. Use dois loops aninhados para visitar cada célula.
#include <stdio.h>
int main(void) {
int grid[2][3] = {{1, 2, 3}, {4, 5, 6}};
printf("%d\n", grid[1][2]); // 6
for (int r = 0; r < 2; r++) {
for (int c = 0; c < 3; c++) {
printf("%d ", grid[r][c]);
}
}
printf("\n"); // 1 2 3 4 5 6
return 0;
}
Erros comuns
C NÃO verifica os limites do array: escrever a[n] em um array de tamanho n é comportamento indefinido.
Índices válidos vão de 0 a n - 1.
Na maioria das expressões, um array se converte em ponteiro para seu primeiro elemento, mas o array em si não é um ponteiro. sizeof(a) fornece o tamanho total em bytes de um array real; um parâmetro de array é ajustado para um ponteiro, exigindo que a função receba um comprimento separado.
Um ponteiro 指针 armazena o endereço 地址 de uma variável. &x dá o endereço de x; *p dereferences 解引用 o ponteiro — ele lê ou escreve o valor armazenado lá. Passar um ponteiro permite que uma função mude a variável de quem chamou (passagem por ponteiro).
Um ponteiro armazena um endereço; dereferenciá-lo segue a seta até o valor
#include <stdio.h>
void addOne(int *p) { // p holds an address
*p = *p + 1; // change the value at that address
}
int main(void) {
int x = 10;
int *ptr = &x; // & takes the address of x
printf("%d\n", *ptr); // * reads the value: 10
addOne(&x);
printf("%d\n", x); // 11 — changed through the pointer
return 0;
}
O uso clássico é uma função de troca. Passar valores apenas os copia — a troca é perdida. Passar ponteiros permite que a função acesse as variáveis de quem chamado:
#include <stdio.h>
void swap_values(int a, int b) { // copies: the caller sees nothing
int t = a; a = b; b = t;
}
void swap_pointers(int *a, int *b) { // addresses: the swap is real
int t = *a; *a = *b; *b = t;
}
int main(void) {
int x = 1, y = 2;
swap_values(x, y);
printf("%d %d\n", x, y); // 1 2 (unchanged!)
swap_pointers(&x, &y);
printf("%d %d\n", x, y); // 2 1 (swapped)
return 0;
}
Um nome de array age como um ponteiro para seu primeiro elemento, e a aritmética de ponteiros 指针运算 avança por elementos inteiros:
#include <stdio.h>
int main(void) {
int a[] = {10, 20, 30};
int *p = a; // same as &a[0]
printf("%d\n", *p); // 10
printf("%d\n", *(p + 2)); // 30 — same as a[2]
return 0;
}
NULL é o ponteiro que aponta para nada — verifique-o antes de dereferenciar.
Erros comuns
&x é o endereço de x; *p é o valor armazenado em p.
Nunca use *p em um ponteiro não inicializado ou NULL — isso causa crash ou corrupção de memória.
Para mudar uma variável de quem chamado, passe seu endereço e escreva através do ponteiro.
Uma string C 字符串 é um array de char. Toda string termina com um terminador nulo oculto 空终止符 '\0', que marca onde ela termina. strlen (de <string.h>) conta caracteres até esse '\0'. Imprima uma string inteira com %s e um único caractere 字符 com %c.
#include <stdio.h>
#include <string.h>
int main(void) {
char name[] = "Mei"; // 'M', 'e', 'i', '\0'
printf("%s\n", name); // Mei
printf("%zu\n", strlen(name)); // 3 (stops at '\0')
printf("%c\n", name[0]); // M
return 0;
}
Uma string C é um array de char terminando em um terminador nulo oculto
Você pode traverse uma string fazendo um loop até encontrar '\0'.
#include <stdio.h>
int main(void) {
char word[] = "banana";
int count = 0;
for (int i = 0; word[i] != '\0'; i++) {
if (word[i] == 'a') count++;
}
printf("%d\n", count); // 3
return 0;
}
7.2
A biblioteca string.h
#include <string.h> oferece as ferramentas cotidianas de string:
Função
Faz
strlen(s)
o comprimento, sem contar o terminador
strcpy(dst, src)
copiar — dst deve ser grande o suficiente
strcat(dst, src)
anexar src ao final de dst
strcmp(a, b)
comparar: 0 se iguais, senão negativo / positivo
#include <stdio.h>
#include <string.h>
int main(void) {
char full[40];
strcpy(full, "Mei"); // full is now "Mei"
strcat(full, " Chen"); // append -> "Mei Chen"
printf("%s (%zu)\n", full, strlen(full)); // Mei Chen (8)
printf("%d\n", strcmp("apple", "apple") == 0); // 1 (equal)
return 0;
}
strcmp retorna 0 para iguais, então o teste é strcmp(a, b) == 0 — nunca a == b.
O array de destino deve ter espaço para o resultado mais o terminador.
Erros comuns
Uma string C precisa de um byte extra para o terminador \0: uma palavra de 5 letras precisa de char[6].
Copie e compare strings com strcpy / strcmp, não = / ==.
Esquecer o terminador \0 faz printf("%s", ...) passar do fim do texto.
Um struct 结构体 agrupa valores relacionados em um único tipo. Cada valor é um membro 成员. typedef dá um nome curto ao struct para que você possa escrever Dog em vez de struct Dog. Use . em um valor de struct, mas -> em um ponteiro para um struct.
#include <stdio.h>
typedef struct {
char name[20];
int age;
} Dog;
int main(void) {
Dog d = {"Rex", 3};
printf("%s is %d\n", d.name, d.age); // Rex is 3 (. on a value)
Dog *p = &d;
p->age = 4; // -> on a pointer
printf("%s is %d\n", d.name, d.age); // Rex is 4
return 0;
}
Erros comuns
Use . em um valor de struct e -> em um ponteiro para uma struct.
typedef permite omitir a palavra struct na declaração; sem ela você escreve struct Point p;.
Atribuir um struct a outro copia todos os seus campos.
. para valores de struct; -> para ponteiros para structs
malloc aloca memória no heap em tempo de execução e retorna um ponteiro para ela. realloc redimensiona esse bloco; free devolve-o. Cada malloc precisa de um free correspondente, ou você terá vazamento de memória. Eles residem em <stdlib.h>.
Locais vivem na pilha; memória de malloc vive no heap até você fazer free
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int n = 3;
int *a = malloc(n * sizeof(int)); // room for 3 ints
if (a == NULL) return EXIT_FAILURE;
for (int i = 0; i < n; i++) a[i] = i * 10;
int *grown = realloc(a, 4 * sizeof *a); // positive size
if (grown == NULL) {
free(a);
return EXIT_FAILURE;
}
a = grown;
a[3] = 30;
for (int i = 0; i < 4; i++) printf("%d ", a[i]);
printf("\n"); // 0 10 20 30
free(a); // hand the memory back
return 0;
}
calloc(n, size) aloca um array como malloc E o preenche com zeros.
Erros comuns
Todo malloc precisa de um free correspondente; esquecer de free causa vazamento de memória.
Usar memória após free (um "uso após liberação") é um bug grave.
Verifique se malloc não retornou NULL antes de usar a memória.
Para tamanhos positivos, uma falha em realloc retorna NULL e mantém a alocação antiga intacta: verifique um resultado temporário antes de substituir seu único ponteiro. O sucesso preserva a menor contagem de bytes antiga/nova; células adicionadas são não inicializadas. Este exemplo evita solicitações de tamanho zero e transbordamento de tamanho. Locais não-estáticos comuns têm duração de armazenamento automática e geralmente são implementados em pilha; C não exige esse layout.
Uma lista encadeada 链表 é uma cadeia de nós 节点. Cada nó contém um valor e um ponteiro para o nó next; o último aponta para NULL. Diferente de um array, cresce um nó de cada vez com malloc. Sempre free cada nó quando terminar.
Uma lista encadeada: cada nó segura um valor e um ponteiro para o próximo, terminando em NULL
#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
int value;
struct Node *next;
} Node;
int main(void) {
Node *head = NULL;
for (int v = 10; v <= 30; v += 10) { // prepend 10, 20, 30
Node *n = malloc(sizeof(Node));
n->value = v;
n->next = head;
head = n;
}
for (Node *p = head; p != NULL; p = p->next) {
printf("%d ", p->value); // 30 20 10
}
printf("\n");
while (head != NULL) { // free the whole list
Node *t = head;
head = head->next;
free(t);
}
return 0;
}
10.2
Pilhas e filas
Uma pilha 栈 é LIFO 后进先出 (last in, first out): push e pop na mesma extremidade. Uma fila 队列 é FIFO 先进先出 (first in, first out): adiciona atrás, remove da frente. Ambas são fáceis de construir em um array com variáveis de índice.
#include <stdio.h>
int main(void) {
int stack[10];
int top = 0; // next free slot
stack[top++] = 1; // push
stack[top++] = 2;
stack[top++] = 3;
while (top > 0) {
printf("%d ", stack[--top]); // pop: 3 2 1
}
printf("\n");
return 0;
}
#include <stdio.h>
int main(void) {
int queue[10];
int front = 0, back = 0;
queue[back++] = 1; // enqueue
queue[back++] = 2;
queue[back++] = 3;
while (front < back) {
printf("%d ", queue[front++]); // dequeue: 1 2 3
}
printf("\n");
return 0;
}
Erros comuns
Em uma lista encadeada, nunca perca o ponteiro head, caso contrário toda a lista ficará inacessível.
Free todos os nós quando terminar, percorrendo a lista antes de desvincular.
Verifique se há uma lista vazia (uma cabeça NULL) antes de fazer o pop.
A busca linear 线性查找 verifica cada elemento por sua vez — funciona em qualquer array. A busca binária 二分查找 é muito mais rápida, mas exige um array ordenado 已排序: verifica o meio e descarta metade a cada passo. Ambas retornam o índice, ou -1 se ausente.
#include <stdio.h>
int linear(int a[], int n, int target) {
for (int i = 0; i < n; i++)
if (a[i] == target) return i;
return -1;
}
int binary(int a[], int n, int target) {
int lo = 0, hi = n - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (a[mid] == target) return mid;
else if (a[mid] < target) lo = mid + 1;
else hi = mid - 1;
}
return -1;
}
int main(void) {
int a[] = {2, 5, 8, 12, 16, 23};
int n = sizeof(a) / sizeof(a[0]);
printf("%d %d %d\n", linear(a, n, 12), binary(a, n, 12), binary(a, n, 9));
return 0; // 3 3 -1
}
Linear varre tudo; binária divide ao meio um intervalo ordenado
11.2
Ordenação
Bubble sort 冒泡排序 compara vizinhos repetidamente e troca 交换 qualquer par fora de ordem. Após cada passada, o maior valor "bolha" para o final.
#include <stdio.h>
int main(void) {
int a[] = {5, 2, 9, 1, 7};
int n = sizeof(a) / sizeof(a[0]);
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - 1 - i; j++) {
if (a[j] > a[j + 1]) {
int t = a[j]; a[j] = a[j + 1]; a[j + 1] = t;
}
}
}
for (int i = 0; i < n; i++) printf("%d ", a[i]);
printf("\n"); // 1 2 5 7 9
return 0;
}
11.3
Recursão
Recursão 递归 é uma função que se chama. Precisa de um caso base 基准情形 para parar, e de uma chamada recursiva que se aproxime dele. Sem um caso base, nunca termina.
#include <stdio.h>
int factorial(int n) {
if (n <= 1) return 1; // base case
return n * factorial(n - 1); // recursive call
}
int main(void) {
printf("%d\n", factorial(5)); // 120
return 0;
}
Erros comuns
Busca binária precisa de um array ordenado; recursão precisa de um caso base.
Cada chamada recursiva deve se aproximar do caso base, ou a pilha transborda.
Bubble e insertion sort são O(n²) — ótimos para aprender, lentos em escala.
fopen devolve um ponteiro de arquivo 文件指针; a string de modo 模式 diz o que fazer — "w" escrever, "r" ler, "a" anexar. Escreva com fprintf, leia com fscanf, e sempre fclose quando terminar.
#include <stdio.h>
int main(void) {
FILE *out = fopen("scores.txt", "w"); // open for writing
fprintf(out, "Alice 80\nBob 95\n");
fclose(out);
FILE *in = fopen("scores.txt", "r"); // open for reading
char name[20];
int score;
while (fscanf(in, "%s %d", name, &score) == 2) {
printf("%s -> %d\n", name, score);
}
fclose(in);
return 0;
}
fopen → read/write → fclose
12.2
Tratamento de erros com códigos de retorno
C não possui exceções. Em vez disso, uma função sinaliza falha com um código de retorno 返回码 — por convenção, 0 significa sucesso e zero não-nulo significa erro. O chamador verifica o código antes de confiar no resultado. (fopen segue a mesma ideia: retorna NULL quando falha.)
#include <stdio.h>
// returns 0 on success, -1 if the divisor is 0
int safe_divide(int a, int b, int *result) {
if (b == 0) return -1; // error code
*result = a / b;
return 0; // success
}
int main(void) {
int r;
if (safe_divide(10, 2, &r) == 0)
printf("10 / 2 = %d\n", r); // 10 / 2 = 5
if (safe_divide(10, 0, &r) != 0)
printf("cannot divide by zero\n"); // error reported
return 0;
}
Erros comuns
Verifique se fopen não retornou NULL antes de ler ou escrever.
Sempre feche fclose um arquivo quando terminar.
Retorne um código não-nulo de main para sinalizar um erro ao chamador.
Um bit 位 é um único 0 ou 1; números são armazenados em binário 二进制. Operadores bitwise 按位 operam diretamente nos bits: & AND, | OR, ^ XOR, << deslocamento à esquerda (×2 a cada passo), >> deslocamento à direita (÷2).
#include <stdio.h>
int main(void) {
int a = 12; // 1100
int b = 10; // 1010
printf("%d\n", a & b); // 8 AND -> 1000
printf("%d\n", a | b); // 14 OR -> 1110
printf("%d\n", a ^ b); // 6 XOR -> 0110
printf("%d\n", a << 1); // 24 left shift
printf("%d\n", a >> 1); // 6 right shift
return 0;
}
Hexadecimal 十六进制 (base 16) escreve binário de forma compacta: um dígito hex corresponde exatamente a quatro bits. Escreva literais hex com 0x; imprima com %x:
#include <stdio.h>
int main(void) {
printf("%d\n", 0xFF); // 255 (0x marks a hex literal)
printf("%x\n", 255); // ff
printf("%x\n", 12); // c
return 0;
}
Operadores bit a bit funcionam nos bits de inteiros
13.2
Codificação por comprimento de corrida
Run-length encoding (RLE) é um método simples de compressão 压缩: substitui cada run 游程 de caracteres repetidos por uma contagem e o caractere. É lossless 无损 — o original é totalmente recuperável.
#include <stdio.h>
#include <string.h>
int main(void) {
char *s = "aaabbc";
int n = strlen(s);
for (int i = 0; i < n; ) {
char c = s[i];
int run = 0;
while (i < n && s[i] == c) { run++; i++; }
printf("%d%c", run, c); // 3a2b1c
}
printf("\n");
return 0;
}
Erros comuns
& é AND bitwise e && é AND lógico — não os confunda.
Um deslocamento à esquerda << 1 dobra um valor; um deslocamento à direita >> 1 o divide pela metade.
O bit n tem valor 1 << n (C não possui operador de potência **); verifique um bit com (x >> n) & 1.
O pré-processador 预处理器 roda antes da compilação. #define cria uma macro 宏 — texto puro substituído em todo lugar. const cria uma constante 常量 que não pode mudar. static dentro de uma função mantém o valor de uma variável entre chamadas. Uma enum (enumeration 枚举) nomeia um conjunto de inteiros começando em 0.
#include <stdio.h>
#define MAX 100 // macro: text replaced before compiling
enum Color { RED, GREEN, BLUE }; // named integers 0, 1, 2
int next_id(void) {
static int count = 0; // keeps its value between calls
count++;
return count;
}
int main(void) {
const double PI = 3.14; // cannot be changed
printf("%d %.2f\n", MAX, PI); // 100 3.14
printf("%d %d %d\n", RED, GREEN, BLUE); // 0 1 2
int a = next_id();
int b = next_id();
printf("%d %d\n", a, b); // 1 2
return 0;
}
Programas maiores dividem-se entre arquivos: declarações vão em um arquivo de cabeçalho 头文件 (mine.h), incluído com #include "mine.h" — aspas significam seu próprio arquivo, < > significa a biblioteca padrão. Um guard de inclusão (#ifndef MINE_H / #define MINE_H / #endif) impede que um header seja incluído duas vezes.
Erros comuns
#define faz substituição de texto simples sem verificação de tipo; encolha os corpos e argumentos da macro em parênteses.
Um valor const não pode ser alterado após ser definido.
Uma variável local static mantém seu valor entre chamadas à função.
#define, const, enum e static mantêm o código claro