C Handout · ⁨C Feuille d'informations⁩

Tout programme C commence dans main. #include <stdio.h> inclut un header 头文件 afin que vous puissiez utiliser printf pour l'affichage. Une fonction 函数 est un bloc nommé que vous pouvez appeler ; \n crée une nouvelle ligne. main retourne 0 pour indiquer « succès ».

#include <stdio.h>

void greet(void) {
    printf("Hello, world!\n");
}

int main(void) {
    greet();
    printf("I am learning C.\n");
    return 0;
}

C nécessite un type pour chaque variable : int (integer 整数), double (floating-point 浮点数), char (un caractère). printf utilise un format specifier 格式说明符 — %d, %f, %c — pour chaque valeur. / entre deux ints effectue une division entière ; % est le reste 余数.

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

La chaîne de format contrôle à la fois l'impression et la lecture :

scanf("%d", &n) lit l'entrée clavier avec les mêmes spécificateurs (notez le &). Son homologue sscanf analyse des valeurs dans une chaîne, ce qui lui permet de s'exécuter partout :

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

Un commentaire 注释 est une note pour les humains ; le compilateur l'ignore. Utilisez // pour une seule ligne et /* ... */ pour un bloc. Un bon indentation 缩进 et des noms clairs rendent le code facile à lire.

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

Erreurs courantes

• Chaque instruction se termine par ;, et main devrait retourner int (return 0;).
• printf nécessite une chaîne de format : %d pour int, %f pour double, et \n pour une nouvelle ligne.
• Un mauvais format comme %d pour un double imprime des caractères incohérents — respectez le type.

Un if exécute un bloc quand une condition 条件 est vraie. C n'a pas de véritable type booléen 布尔值 par défaut : 0 est faux et toute valeur non nulle est vraie. Enchaînez les choix avec else if et else. Comparez avec ==, !=, <, >, <=, >=.

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

Un switch sélectionne un case basé sur une valeur entière. Chaque case nécessite un break pour sortir 跳出 — sans cela, C « tombe » dans le case suivant. default s'exécute quand rien ne correspond.

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

Erreurs courantes

• if (x = 5) affecte et est toujours vrai ; utilisez == pour comparer.
• Chaque switch case nécessite un break;, sinon il tombe dans le suivant.
• 0 est faux et toute valeur non nulle est vraie dans une condition.

Une boucle 循环 répète un bloc. Une boucle while s'exécute tant qu'une condition est vraie. Une boucle for regroupe l'initialisation, le test et l'incrémentation 自增 (i++) sur une seule ligne — idéal quand on sait combien de fois répéter.

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

Un motif courant : initialiser un accumulateur 累加器 à 0, puis l'incrémenter à l'intérieur d'une boucle. La même logique sert à compter des éléments ou trouver un total cumulé.

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

Une boucle à l'intérieur d'une autre boucle est une boucle imbriquée 嵌套. La boucle intérieure se termine complètement pour chaque étape de la boucle extérieure — parfait pour les grilles et les motifs.

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

Erreurs courantes

• for (i = 0; i < n; i++) s'exécute n fois ; un point-virgule juste après for (...) crée une boucle vide.
• Une while dont la condition ne devient jamais fausse boucle indéfiniment.
• Déclarez le compteur (int i) avant ou dans l'en-tête for.

Une fonction prend des paramètres 参数 (entrées) et retourne une valeur de retour 返回值. Le type de retour se trouve en premier (int, double, …) ; void signifie qu'elle ne retourne rien.

#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 lit de haut en bas, donc une fonction doit être connue avant d'être appelée. Un prototype 函数原型 — la ligne d'en-tête plus ; — la déclare tôt pour que vous puissiez garder main en premier. La portée 作用域 d'une variable est le bloc dans lequel elle existe : elle est locale 局部 et disparaît lorsque le bloc se termine.

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

Erreurs courantes

• Une fonction utilisée avant d'être définie nécessite un prototype au-dessus de main.
• Les arguments sont passés PAR VALEUR — les modifications à l'intérieur d'une fonction n'affectent pas l'appelant sauf si vous passez un pointeur.
• Une variable déclarée à l'intérieur d'une fonction lui est locale.

Un tableau 数组 stocke plusieurs valeurs d'un même type. L'index 索引 commence à 0. C ne stocke pas la longueur du tableau, c'est pourquoi on calcule souvent le nombre d'éléments 元素 : 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;
}

Parcourez 遍历 un tableau avec une boucle for pour trouver un maximum, un total ou un décompte. Bouclez toujours de 0 jusqu'à 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;
}

Un tableau 2-D est une grille de lignes 行 et colonnes 列 : grid[row][col]. Utilisez deux boucles imbriquées pour visiter chaque case.

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

Erreurs courantes

• C ne vérifie PAS les limites du tableau : écrire a[n] dans un tableau de taille n est un comportement non défini.
• Les indices valides vont de 0 à n - 1.
• Le nom du tableau est un pointeur vers son premier élément ; sizeof ne donne la taille que dans la portée propre du tableau.

Un pointeur 指针 stocke l'adresse 地址 d'une variable. &x donne l'adresse de x ; *p déréférence 解引用 le pointeur — il lit ou écrit la valeur stockée là. Passer un pointeur permet à une fonction de modifier la variable de l'appelant (passage par pointeur).

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

L'usage classique est une fonction d'échange. Passer des valeurs ne fait que les copier — l'échange est perdu. Passer des pointeurs permet à la fonction d'accéder aux variables de l'appelant :

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

Le nom d'un tableau agit comme un pointeur vers son premier élément, et l'arithmétique de pointeur 指针运算 avance par éléments entiers :

#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 est un pointeur qui ne pointe sur rien — vérifiez-le avant de le déréférencer.

Erreurs courantes

• &x est l'adresse de x ; *p est la valeur stockée à p.
• N'utilisez jamais *p sur un pointeur non initialisé ou NULL — cela provoque un crash ou une corruption de mémoire.
• Pour modifier la variable de l'appelant, passez son adresse et écrivez via le pointeur.

Une chaîne C 字符串 est un tableau de char. Chaque chaîne se termine par un terminateur null caché 空终止符 '\0', qui marque où elle s'arrête. strlen (depuis <string.h>) compte les caractères jusqu'à ce '\0'. Imprimez une chaîne entière avec %s et un caractère 字符 avec %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;
}

Vous pouvez parcourir une chaîne en bouclant jusqu'à ce que vous atteigniez '\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> vous fournit les outils courants pour les chaînes :

#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 retourne 0 pour l'égalité, donc le test est strcmp(a, b) == 0 — jamais a == b.
• Le tableau de destination doit avoir de la place pour le résultat plus le terminateur.

Erreurs courantes

• Une chaîne C a besoin d'un octet supplémentaire pour le terminateur \0 : un mot de 5 lettres nécessite char[6].
• Copiez et comparez des chaînes avec strcpy / strcmp, pas = / ==.
• Oublier le \0 fait que printf("%s", ...) dépasse la fin du texte.

Une struct 结构体 regroupe des valeurs liées en un seul type. Chaque valeur est un membre 成员. typedef donne à la struct un nom court afin que vous puissiez écrire Dog au lieu de struct Dog. Utilisez . sur une valeur de struct, mais -> sur un pointeur vers une 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;
}

Erreurs courantes

• Utilisez . sur une valeur de struct et -> sur un pointeur de struct.
• typedef vous permet de supprimer le mot struct lors de la déclaration ; sans cela, vous écrivez struct Point p;.
• Assigner une struct à une autre copie tous ses champs.

malloc alloue de la mémoire 分配 sur le tas 堆 à l'exécution et renvoie un pointeur vers celle-ci. realloc redimensionne ce bloc ; free le libère. Chaque malloc nécessite un free correspondant, sinon vous obtenez une fuite de mémoire 内存泄漏. Ceux-ci vivent dans <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) alloue un tableau comme malloc ET le remplit de zéros.

Erreurs courantes

• Chaque malloc nécessite un free correspondant ; oublier de libérer entraîne une fuite de mémoire.
• Utiliser de la mémoire après free (un « use-after-free ») est un bug grave.
• Vérifiez que malloc n'a pas renvoyé NULL avant d'utiliser la mémoire.

Une liste chainée 链表 est une chaîne de nœuds 节点. Chaque nœud contient une valeur et un pointeur vers le nœud next ; le dernier pointe vers NULL. Contrairement à un tableau, elle croît d'un nœud à la fois avec malloc. Libérez toujours free chaque nœud une fois terminé.

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

Une pile 栈 est LIFO 后进先出 (last in, first out) : push et pop à la même extrémité. Une file 队列 est FIFO 先进先出 (first in, first out) : ajout à l'arrière, retrait à l'avant. Les deux sont faciles à implémenter sur un tableau avec des variables d'index.

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

Erreurs courantes

• Dans une liste chainée, ne perdez jamais le pointeur head, sinon toute la liste devient inaccessible.
• Libérez chaque nœud une fois terminé, en parcourant la liste avant de la détacher.
• Vérifiez une liste vide (une tête NULL) avant de faire un pop.

La recherche linéaire 线性查找 vérifie chaque élément à tour de rôle — elle fonctionne sur tout tableau. La recherche binaire 二分查找 est beaucoup plus rapide mais nécessite un tableau trié 已排序 : elle vérifie le milieu et élimine la moitié à chaque étape. Les deux renvoient l'indice, ou -1 s'il est absent.

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

Le tri à bulles 冒泡排序 compare répétitivement les voisins et échange 交换 toute paire qui n'est pas dans l'ordre. Après chaque passage, la plus grande valeur « remonte » à la fin.

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

La récursion 递归 est une fonction qui s'appelle elle-même. Elle a besoin d'un cas de base 基准情形 pour s'arrêter, et d'un appel récursif qui s'en rapproche. Sans cas de base, elle ne se termine jamais.

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

Erreurs courantes

• La recherche binaire nécessite un tableau trié ; la récursion nécessite un cas de base.
• Chaque appel récursif doit se rapprocher du cas de base, sinon la pile déborde.
• Les tris par bulles et par insertion sont en O(n²) — bien à apprendre, lents à grande échelle.

fopen renvoie un pointeur de fichier 文件指针 ; la chaîne de mode 模式 indique quoi faire — "w" écrire, "r" lire, "a" ajouter. Écrivez avec fprintf, lisez avec fscanf, et fermez toujours fclose une fois terminé.

#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'a pas d'exceptions. Au lieu de cela, une fonction signale un échec avec un code de retour 返回码 — par convention, 0 signifie succès et une valeur non nulle signifie une erreur. L'appelant vérifie le code avant de faire confiance au résultat. (fopen suit la même idée : il renvoie NULL en cas d'échec.)

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

Erreurs courantes

• Vérifiez que fopen n'a pas retourné NULL avant de lire ou d'écrire.
• Fermez toujours fclose un fichier une fois terminé.
• Renvoyez un code non nul depuis main pour signaler une erreur à l'appelant.

Un bit 位 est un 0 ou 1 unique ; les nombres sont stockés en binaire 二进制. Les opérateurs bit à bit 按位 agissent directement sur les bits : & AND, | OR, ^ XOR, << décalage vers la gauche (×2 à chaque étape), >> décalage vers la droite (÷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;
}

L'hexadécimal 十六进制 (base 16) écrit le binaire de manière compacte : un chiffre hexadécimal correspond exactement à quatre bits. Écrivez les littéraux hexadécimaux avec 0x ; affichez avec %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;
}

La compression par codage de longueur d'exécution (RLE) est une méthode 压缩 simple : remplacez chaque série 游程 de caractères répétés par un compteur et le caractère. C'est sans perte 无损 — l'original est entièrement récupérable.

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

Erreurs courantes

• & est un ET bit à bit et && est un ET logique — ne les confondez pas.
• Un décalage à gauche << 1 double une valeur ; un décalage à droite >> 1 la divise par deux.
• Le bit n a la valeur 1 << n (C n'a pas d'opérateur ** de puissance) ; vérifiez un bit avec (x >> n) & 1.

Le préprocesseur 预处理器 s'exécute avant la compilation. #define crée une macro 宏 — du texte brut remplacé partout. const crée une constante 常量 qui ne peut pas changer. static dans une fonction conserve la valeur d'une variable entre les appels. Une énumération 枚举 enum nomme un ensemble d'entiers commençant à 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;
}

Les programmes plus grands sont répartis sur plusieurs fichiers : les déclarations vont dans un fichier d'en-tête 头文件 (mine.h), inclus avec #include "mine.h" — les guillemets signifient votre propre fichier, < > signifie la bibliothèque standard. Un garde d'inclusion (#ifndef MINE_H / #define MINE_H / #endif) empêche qu'un en-tête soit inclus deux fois.

Erreurs courantes

• #define effectue un remplacement de texte brut sans vérification de type ; enroulez les corps et arguments des macro dans des parenthèses.
• Une valeur const ne peut pas être modifiée après qu'elle a été définie.
• Une variable locale static conserve sa valeur entre les appels à la fonction.