Passer au contenu
Sujets
  • 1 Bases C
    1.1

    main, printf & fonctions

    Chaque programme C commence à main. #include <stdio.h> inclut un en-tête pour pouvoir utiliser printf pour l'impression. Une fonction est un bloc nommé que vous pouvez appeler ; \n crée une nouvelle ligne. main retourne 0 pour signifier « succès ».

    #include <stdio.h>
    
    void greet(void) {
        printf("Hello, world!\n");
    }
    
    int main(void) {
        greet();
        printf("I am learning C.\n");
        return 0;
    }
    
    Chaque programme C s'exécute à partir de main après avoir inclus les headers
    Chaque programme C s'exécute à partir de main après avoir inclus les headers
    1.2

    Variables, types & arithmétique

    C nécessite un type pour chaque variable : int (entier), double (virgule flottante), char (un seul caractère). printf utilise un format spécificateur — %d, %f, %c — pour chaque valeur. / entre deux entiers est 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 :

    Spécificateur Type Exemple de sortie
    %d int 17
    %f double (%.2f = 2 décimales) 3.14
    %c char A
    %s une chaîne de caractères Mei
    %zu une taille (de sizeof / strlen) 3
    %x unsigned int, imprimé en base 16 ff

    scanf("%d", &n) lit un int via son adresse (notez le &). Les formats d'entrée et de sortie ne sont pas identiques : printf("%f", x) affiche un double, mais scanf("%lf", &x) lit un double ; l'entrée %f nécessite un float *. Vérifiez le nombre retourné d'éléments assignés avec succès. Son sibling sscanf extrait des valeurs d'une chaîne :

    #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

    Commentaires & style

    Un commentaire est une note pour les humains ; le compilateur l'ignore. Utilisez // pour une seule ligne et /* ... */ pour un bloc. Une bonne 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

    • Les déclarations et expressions se terminent par ; ; un bloc composé { ... } ne nécessite pas de point-virgule supplémentaire. 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 format incorrect comme %d pour un double provoque un comportement indéfini ; il n'est pas garanti qu'il n'imprime que des caractères aléatoires. Faites correspondre le type de l'argument.
  • 2 Sélection
    2.1

    if / else

    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;
    }
    
    if choisit la branche vraie ; else la branche fausse
    if choisit la branche vraie ; else la branche fausse
    2.2

    interrupteur

    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.
  • 3 Boucles
    3.1

    boucles while & for

    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;
    }
    
    while vérifie une condition ; for compte avec un pas
    while vérifie une condition ; for compte avec un pas
    3.2

    Accumulation

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

    Boucles imbriquées & motifs

    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.
  • 4 Fonctions
    4.1

    Paramètres et valeurs de retour

    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;
    }
    
    Paramètres in; valeur de retour out
    Paramètres in; valeur de retour out
    4.2

    Prototypes et portée

    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.
  • 5 Tableaux
    5.1

    Tableaux 1-D

    Un tableau contient plusieurs valeurs d'un même type. Indexez à partir de 0. C ne stocke pas la longueur d'un tableau, aussi une astuce courante calcule 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;
    }
    
    Les cases du tableau sont indexées à partir de 0
    Les cases du tableau sont indexées à partir de 0
    5.2

    Algorithmes sur tableaux

    Parcourez un tableau avec une boucle for pour trouver un max, un total ou un compteur. 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;
    }
    
    5.3

    Tableaux 2-D

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

    #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.
    • Dans la plupart des expressions, un tableau se convertit en pointeur vers son premier élément, mais le tableau lui-même n'est pas un pointeur. sizeof(a) donne la taille totale en octets pour un tableau réel ; un paramètre de tableau est ajusté en pointeur, donc cette fonction a besoin d'une longueur fournie séparément.
  • 6 Pointeurs
    6.1

    &, * et passage par pointeur

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

    Un pointeur stocke une adresse ; sa déréference suit la flèche vers la valeur
    Un pointeur stocke une adresse ; sa déréference suit la flèche vers la valeur
    #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.
  • 7 Chaînes de Caractères
    7.1

    Tableaux de caractères & terminateur nul

    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;
    }
    
    Une chaîne C est un tableau de char se terminant par un terminateur nul caché
    Une chaîne C est un tableau de char se terminant par un terminateur nul caché

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

    La bibliothèque string.h

    #include <string.h> vous fournit les outils courants pour les chaînes :

    Fonction Fait
    strlen(s) la longueur, sans compter le terminateur
    strcpy(dst, src) copier — dst doit être assez grand
    strcat(dst, src) ajouter src à la fin de dst
    strcmp(a, b) comparer : 0 si égal, sinon négatif / positif
    #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.
  • 8 Structures
    8.1

    struct, typedef, . vs ->

    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.
    . pour les valeurs de structure ; -> pour les pointeurs vers des structures
    . pour les valeurs de struct ; -> pour les pointeurs vers des structs
  • 9 Mémoire dynamique
    9.1

    malloc, free & realloc

    malloc alloue de la mémoire sur le tas au moment de l'exécution et retourne un pointeur vers celle-ci. realloc redimensionne ce bloc ; free la restitue. Chaque malloc nécessite un free correspondant, sinon vous avez une fuite de mémoire. Ceux-ci vivent dans <stdlib.h>.

    Les variables locales sont stockées sur la pile ; la mémoire allouée par malloc se trouve dans le tas jusqu'à ce que vous la libériez
    Les variables locales vivent sur la pile ; la mémoire malloc vit sur le tas jusqu'à ce que vous la libériez
    #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) 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.

    Pour des tailles positives, un échec realloc retourne NULL et laisse l'allocation précédente intacte : vérifiez un résultat temporaire avant de remplacer votre unique pointeur. Le succès préserve le plus petit des comptes d'octets anciens/nouveaux ; les cellules ajoutées sont non initialisées. Cet exemple évite les demandes de taille zéro et le dépassement de taille. Les variables locales ordinaires non statiques ont une durée de vie automatique et sont généralement implémentées sur une pile ; C ne requiert pas cette disposition.

  • 10 Structures de données
    10.1

    Listes chainées

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

    Une liste chaînée : chaque nœud contient une valeur et un pointeur vers le suivant, se terminant par NULL
    Une liste chainée : chaque nœud contient une valeur et un pointeur vers le suivant, se terminant à 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

    Piles et files

    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.
  • 11 Recherche, tri & récursion
    11.1

    Recherche linéaire et binaire

    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
    }
    
    Les scans linéaires parcourent tout ; le binaire divise un trié en deux
    La recherche linéaire scanne tout ; la recherche binaire divise par deux un intervalle trié
    11.2

    Tri

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

    Récursivité

    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.
  • 12 Fichiers & erreurs
    12.1

    Fichiers texte

    fopen retourne un pointeur de fichier ; la chaîne de mode indique l'action — "w" écriture, "r" lecture, "a" ajout. Écrivez avec fprintf, lisez avec fscanf, et fermez toujours le flux fclose une fois terminé.

    #include <stdio.h>
    
    int main(void) {
        FILE *out = fopen("scores.txt", "w");   // open for writing
        if (out == NULL) {
            perror("scores.txt");
            return 1;
        }
        fprintf(out, "Alice 80\nBob 95\n");
        fclose(out);
    
        FILE *in = fopen("scores.txt", "r");    // open for reading
        if (in == NULL) {
            perror("scores.txt");
            return 1;
        }
        char name[20];
        int score;
        while (fscanf(in, "%19s %d", name, &score) == 2) {   // %19s leaves room for '\0'
            printf("%s -> %d\n", name, score);
        }
        fclose(in);
        return 0;
    }
    
    fopen → lecture/écriture → fclose
    fopen → lecture/écriture → fclose
    12.2

    Gestion d'erreurs avec codes de retour

    Le langage C ne possède pas d'exceptions intégrées. Une fonction peut signaler son résultat via un code de retour ; vérifiez les règles de cette fonction avant d'utiliser le résultat. L'exemple ci-dessous utilise 0 pour la réussite et -1 pour l'échec. La fonction fopen retourne à la place un pointeur de flux, ou 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.
  • 13 Bits & données
    13.1

    Bits, binaire et opérateurs bit à bit

    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;
    }
    
    Les opérateurs bit à bit travaillent sur les bits des entiers
    Les opérateurs bitwise travaillent sur les bits des entiers
    13.2

    Codage par longueur de run

    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.
  • 14 Préprocesseur & qualificateurs
    14.1

    Préprocesseur, const, static, enum

    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.
    #define, const, enum et static rendent le code clair
    #define, const, enum et static maintiennent le code clair

Se connecter ou créer un compte

IGCSE, A-Level & AP