C Handout

Todo programa C começa em main. #include <stdio.h> inclui um cabeçalho 头文件 para que você possa usar printf para imprimir. Uma função 函数 é um bloco nomeado que você pode chamar; \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

C precisa de um tipo para cada variável: int (inteiro 整数), double (ponto flutuante 浮点数), char (um 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:

scanf("%d", &n) lê entrada do teclado com os mesmos especificadores (note o &). Seu irmão sscanf analisa valores de uma string, então ele roda em qualquer lugar:

#include <stdio.h>

int main(void) {
    char line[] = "Mei 88";
    char name[20];
    int score;
    sscanf(line, "%19s %d", name, &score);   // parse text -> values
    printf("%s scored %d\n", name, score);   // Mei scored 88
    return 0;
}

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

• Toda instrução termina com ;, e 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 imprime lixo — corresponda o tipo.

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

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

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;
}

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;
}

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.

Um array 数组 armazena vários valores de um único tipo. Índice 索引 começa em 0. C não armazena o tamanho do array, então um truque 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;
}

Traverse 遍历 um array 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;
}

Um array 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.
• O nome do array é um ponteiro para seu primeiro elemento; sizeof só dá o tamanho no próprio escopo do array.

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).

#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;
}

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;
}

#include <string.h> oferece as ferramentas cotidianas de string:

#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.

malloc aloca 分配 memória no heap 堆 em tempo de execução e devolve um ponteiro para ela. realloc redimensiona esse bloco; free a devolve. Todo malloc precisa de um free correspondente, ou você terá vazamento de memória 内存泄漏. Estes vivem em <stdlib.h>.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int n = 3;
    int *a = malloc(n * sizeof(int));    // room for 3 ints
    for (int i = 0; i < n; i++) a[i] = i * 10;

    a = realloc(a, 4 * sizeof(int));     // grow to 4 ints
    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.

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.

#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;
}

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
}

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;
}

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;
}

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;
}

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.