# Sommaire — Cours complet de programmation en C > **Périmètre du cours :** C **pur**, du niveau débutant jusqu’à un niveau avancé, avec une ouverture vers la portabilité, les environnements d’exécution, les outils de build, la distribution, l’ABI/FFI, le réseau, les threads, la bibliothèque standard, ainsi que les référentiels de qualité et de sécurité. --- ## Chapitre 0 — Introduction générale 0.1. Présentation du langage C 0.2. Historique du C 0.3. Pourquoi apprendre le C aujourd’hui 0.4. Domaines d’usage du C 0.5. Ce que le C permet, et ce qu’il ne fait pas à votre place 0.6. Programme minimal : `main` et premier `printf` --- ## Chapitre 1 — Normes du langage C 1.1. Qu’est-ce qu’une norme 1.2. ANSI C / C89 / C90 1.3. C95 1.4. C99 1.5. C11 1.6. C17 / C18 1.7. C23 1.8. Différences majeures entre les versions 1.9. Comment choisir une norme dans un compilateur 1.10. Extensions de compilateur vs C standard --- ## Chapitre 2 — Environnements et portabilité 2.1. C hébergé et C freestanding 2.2. Linux, Windows, macOS 2.3. Android et autres plateformes mobiles 2.4. Microcontrôleurs et systèmes embarqués 2.5. Différences entre architecture, OS et compilateur 2.6. Endianness, taille des types et modèle mémoire 2.7. Ce qui est portable et ce qui ne l’est pas 2.8. Dépendances système et couches d’abstraction 2.9. Écrire du C réellement portable --- ## Chapitre 3 — Outils et chaîne de compilation 3.1. Compilateurs : gcc, clang, autres 3.2. Préprocesseur, compilation, assemblage, édition de liens 3.3. Fichiers source, objets, exécutables 3.4. Warnings, erreurs, diagnostics 3.5. Options importantes du compilateur 3.6. Standards de compilation (`-std=c99`, `-std=c11`, etc.) 3.7. Fichiers de debug 3.8. Compilation séparée 3.9. Compilation croisée --- ## Chapitre 4 — Structure d’un programme C 4.1. Fonction `main` 4.2. Instructions et blocs 4.3. Commentaires 4.4. Déclarations 4.5. Définitions 4.6. En-têtes `.h` et sources `.c` 4.7. Organisation minimale d’un projet --- ## Chapitre 5 — Variables, objets, portée et durée de vie 5.1. Déclaration et initialisation 5.2. Variables locales 5.3. Variables globales 5.4. Variables de fichier 5.5. Variables `static` 5.6. Variables `extern` 5.7. Portée de bloc 5.8. Portée de fichier 5.9. Durée de vie automatique, statique et dynamique 5.10. Constantes et immutabilité apparente avec `const` --- ## Chapitre 6 — Types fondamentaux 6.1. `char`, `short`, `int`, `long`, `long long` 6.2. Types signés et non signés 6.3. `float`, `double`, `long double` 6.4. `_Bool` / `bool` 6.5. `void` 6.6. Tailles minimales garanties par la norme 6.7. Types entiers fixes de `` 6.8. Types de taille et d’index (`size_t`, `ptrdiff_t`) 6.9. Qualificateurs de type --- ## Chapitre 7 — Mémoire, représentation et conversions 7.1. Octets, adresses et objets 7.2. Représentation en mémoire 7.3. Alignement 7.4. `sizeof` et `_Alignof` / `alignof` selon la norme 7.5. Promotions entières 7.6. Conversions implicites 7.7. Casts explicites 7.8. Troncatures, dépassements et pertes de précision 7.9. Lecture correcte des types composés --- ## Chapitre 8 — Opérateurs et expressions 8.1. Opérateurs arithmétiques 8.2. Opérateurs relationnels 8.3. Opérateurs logiques 8.4. Opérateurs d’affectation 8.5. Incrémentation et décrémentation 8.6. Opérateurs binaires et bit à bit 8.7. Priorité et associativité 8.8. Effets de bord 8.9. Ordre d’évaluation et pièges classiques --- ## Chapitre 9 — Contrôle du flux 9.1. `if`, `else`, `else if` 9.2. `switch` 9.3. `for` 9.4. `while` 9.5. `do ... while` 9.6. `break` 9.7. `continue` 9.8. `goto` 9.9. Retour anticipé 9.10. Structurer un flux lisible --- ## Chapitre 10 — Fonctions 10.1. Déclaration, définition, prototype 10.2. Paramètres et valeur de retour 10.3. Passage par valeur 10.4. Simulation du passage par référence avec pointeur 10.5. Récursion 10.6. Fonctions `static` 10.7. Fonctions variadiques 10.8. Organisation des API en C --- ## Chapitre 11 — Tableaux 11.1. Déclaration de tableaux 11.2. Initialisation 11.3. Parcours 11.4. Tableaux multidimensionnels 11.5. Taille logique vs taille mémoire 11.6. Décroissance tableau → pointeur 11.7. Passage d’un tableau à une fonction 11.8. Erreurs fréquentes sur les bornes --- ## Chapitre 12 — Chaînes de caractères 12.1. `char[]` et terminaison `\0` 12.2. Littéraux de chaîne 12.3. Différence entre tableau et pointeur sur chaîne 12.4. Longueur, copie, concaténation 12.5. Comparaison 12.6. Fonctions utiles de `` 12.7. Limites des fonctions non bornées 12.8. Manipulation robuste des buffers texte --- ## Chapitre 13 — Pointeurs 13.1. Adresse d’un objet 13.2. Déclaration de pointeurs 13.3. Déréférencement 13.4. Pointeur nul 13.5. Pointeurs et tableaux 13.6. Arithmétique des pointeurs 13.7. Pointeur vers pointeur 13.8. `const` avec les pointeurs 13.9. Pièges classiques --- ## Chapitre 14 — Allocation dynamique 14.1. Mémoire automatique vs dynamique 14.2. `malloc` 14.3. `calloc` 14.4. `realloc` 14.5. `free` 14.6. Vérification des erreurs 14.7. Fuites mémoire 14.8. Double libération 14.9. Pointeurs pendants 14.10. Stratégies de gestion mémoire --- ## Chapitre 15 — Structures, unions et énumérations 15.1. `struct` 15.2. Accès aux champs 15.3. Structures imbriquées 15.4. Tableaux de structures 15.5. Pointeurs vers structures 15.6. `union` 15.7. Cas d’usage des unions 15.8. `enum` 15.9. Représentation et limites 15.10. `typedef` et lisibilité --- ## Chapitre 16 — Préprocesseur 16.1. `#include` 16.2. `#define` objet 16.3. Macros avec paramètres 16.4. Parenthésage et pièges 16.5. Compilation conditionnelle 16.6. Include guards 16.7. `#if`, `#ifdef`, `#ifndef`, `#elif`, `#endif` 16.8. Macros de compilation courantes 16.9. Quand éviter les macros --- ## Chapitre 17 — Bibliothèque standard C : vue d’ensemble 17.1. Rôle de la libc 17.2. Ce qui relève du langage et ce qui relève de la bibliothèque 17.3. En-têtes standards 17.4. Fonctions, macros, types et constantes 17.5. Limites de la bibliothèque standard 17.6. Différences entre implémentations de libc 17.7. Hosted vs freestanding pour la bibliothèque --- ## Chapitre 18 — La libc en pratique, partie 1 : entrées/sorties 18.1. `` 18.2. `printf`, `fprintf`, `snprintf` 18.3. `scanf` et ses limites 18.4. Flux `stdin`, `stdout`, `stderr` 18.5. Tamponnement 18.6. Lecture ligne par ligne 18.7. Gestion des erreurs d’E/S --- ## Chapitre 19 — La libc en pratique, partie 2 : chaînes, mémoire, utilitaires 19.1. `` 19.2. `` 19.3. `` 19.4. `` 19.5. `` 19.6. `` 19.7. `` 19.8. `` et `` 19.9. `` et `` --- ## Chapitre 20 — Modularité et organisation d’un projet 20.1. Séparer interface et implémentation 20.2. Concevoir un bon fichier d’en-tête 20.3. Déclarations publiques et privées 20.4. `static` de fichier 20.5. `extern` 20.6. API interne vs API externe 20.7. Arborescence d’un projet C 20.8. Convention de nommage 20.9. Documentation technique minimale --- ## Chapitre 21 — Types de projets en C 21.1. Programme exécutable 21.2. Bibliothèque statique 21.3. Bibliothèque dynamique / partagée 21.4. Outil en ligne de commande 21.5. Service système 21.6. Bibliothèque embarquée 21.7. Plugin 21.8. Tests et utilitaires internes 21.9. Choisir le bon type de livrable --- ## Chapitre 22 — Édition de liens, ABI et binaire 22.1. Qu’est-ce que le linking 22.2. Symboles 22.3. Résolution des références externes 22.4. Bibliothèques statiques et dynamiques 22.5. Nom mangling et compatibilité C 22.6. ABI : définition et enjeux 22.7. Convention d’appel 22.8. Alignement, padding et compatibilité binaire 22.9. Stabilité d’ABI 22.10. Inspection d’un binaire --- ## Chapitre 23 — Interopérabilité et FFI 23.1. Qu’est-ce que la FFI 23.2. Exposer une API C propre 23.3. Consommer une bibliothèque écrite en C 23.4. Compatibilité avec d’autres langages 23.5. Contraintes de structure mémoire 23.6. Gestion des erreurs à la frontière FFI 23.7. API stable et versionnement 23.8. Bonnes pratiques d’interface --- ## Chapitre 24 — Partie système : principes généraux 24.1. Ce que le langage C standard ne couvre pas 24.2. Appels système et API système 24.3. POSIX : idée générale 24.4. Différences POSIX / Windows 24.5. Processus et environnement d’exécution 24.6. Variables d’environnement 24.7. Répertoires et chemins 24.8. Horloge, temps, dates 24.9. Signaux : introduction 24.10. Limites de la portabilité système --- ## Chapitre 25 — Fichiers, répertoires et système de fichiers 25.1. Fichiers texte et binaires 25.2. Chemins relatifs et absolus 25.3. Métadonnées 25.4. Répertoires 25.5. Permissions 25.6. Opérations courantes sur les fichiers 25.7. Portabilité des chemins 25.8. Encodages et fin de ligne 25.9. Accès bas niveau vs libc --- ## Chapitre 26 — Processus et exécution 26.1. Processus et programme 26.2. Arguments de la ligne de commande 26.3. Code de retour 26.4. Lancer un autre programme 26.5. Attendre un processus fils 26.6. Redirections 26.7. Communication simple entre processus 26.8. Particularités multi-plateformes --- ## Chapitre 27 — Threads et concurrence 27.1. Notions de concurrence et de parallélisme 27.2. Données partagées 27.3. Conditions de course 27.4. Threads C11 27.5. Threads POSIX 27.6. Mutex 27.7. Variables de condition 27.8. Atomiques C11 27.9. Visibilité mémoire 27.10. Concevoir du code thread-safe --- ## Chapitre 28 — Réseau en C 28.1. Ce que signifie programmer le réseau 28.2. Sockets 28.3. IPv4 et IPv6 28.4. TCP et UDP 28.5. Résolution de noms 28.6. Serveur simple 28.7. Client simple 28.8. Blocant vs non bloquant 28.9. Portabilité réseau 28.10. Gestion correcte des erreurs réseau --- ## Chapitre 29 — Gestion des erreurs 29.1. Codes de retour 29.2. `errno` 29.3. `perror` et `strerror` 29.4. Stratégies d’erreur en bibliothèque 29.5. Nettoyage en cas d’échec 29.6. Contrats et préconditions 29.7. Assertions et vérifications 29.8. Erreurs récupérables et fatales --- ## Chapitre 30 — Undefined Behavior, comportements indéfinis et pièges 30.1. Définition de l’UB 30.2. Unspecified behavior 30.3. Implementation-defined behavior 30.4. Exemples classiques d’UB 30.5. Dépassements, aliasing, accès hors limites 30.6. Ordre d’évaluation 30.7. Pointeurs invalides 30.8. Pourquoi le compilateur peut “casser” votre intuition 30.9. Méthodes pour éviter ces erreurs --- ## Chapitre 31 — Débogage, analyse et qualité 31.1. Compiler avec les bons warnings 31.2. Niveau d’optimisation et debug 31.3. gdb / lldb : notions utiles 31.4. Sanitizers 31.5. Analyse statique 31.6. Outils mémoire 31.7. Traces et logs 31.8. Reproduire un bug 31.9. Vérifier un comportement suspect --- ## Chapitre 32 — Build systems et automatisation 32.1. Compilation manuelle 32.2. `make` 32.3. Structure d’un `Makefile` 32.4. Variables, règles, dépendances 32.5. Builds debug et release 32.6. `cmake` 32.7. Génération multi-plateforme 32.8. Autres outils de build 32.9. Organisation d’un pipeline de build --- ## Chapitre 33 — Tests 33.1. Pourquoi tester en C 33.2. Tests unitaires 33.3. Tests d’intégration 33.4. Programmes de test maison 33.5. Frameworks de test 33.6. Fichiers de données de test 33.7. Couverture de code 33.8. Régression et automatisation --- ## Chapitre 34 — Packaging et distribution 34.1. Distribuer un exécutable 34.2. Distribuer une bibliothèque 34.3. Gestion des dépendances 34.4. Distribution Linux 34.5. Distribution Windows 34.6. Distribution macOS 34.7. Packaging cross-platform 34.8. Installeurs, archives, paquets 34.9. Versionnement 34.10. Compatibilité et support --- ## Chapitre 35 — Sécurité, sûreté et standards industriels 35.1. Sécurité mémoire en C 35.2. Surfaces d’attaque classiques 35.3. Entrées non fiables 35.4. CERT C 35.5. MISRA C 35.6. Contexte embarqué et critique 35.7. Déviations documentées 35.8. Revue de code et exigences qualité 35.9. Écrire du C plus sûr sans changer de langage --- ## Chapitre 36 — Bonnes pratiques de style et conception 36.1. Lisibilité 36.2. Simplicité 36.3. Interfaces claires 36.4. Cohérence de nommage 36.5. Réduction du couplage 36.6. Limitation des effets de bord 36.7. Documentation utile 36.8. Conception défensive 36.9. Maintenabilité long terme --- ## Chapitre 37 — Projet final complet 37.1. Choix du sujet 37.2. Spécification 37.3. Architecture 37.4. Modules et fichiers 37.5. Build 37.6. Tests 37.7. Packaging 37.8. Distribution 37.9. Améliorations possibles --- ## Chapitre 38 — Annexes 38.1. Glossaire 38.2. Tableau récapitulatif des types 38.3. Tableau récapitulatif de la libc 38.4. Tableau des normes C 38.5. Rappels sur la compilation 38.6. Checklist de portabilité 38.7. Checklist de sécurité 38.8. Mini aide-mémoire des commandes utiles