Au-delà de la syntaxe, la maîtrise du C passe par la gestion fine de la mémoire et l’organisation rigoureuse du code. Cette formation avancée, alignée sur la norme C17, couvre l’allocation dynamique, le débogage avec gdb et valgrind, les sanitizers ASan, UBSan et TSan, les tests unitaires, la concurrence C11 avec threads et atomics, la compilation modulaire avec Makefile et les structures de données complexes telles qu’arbres, tables de hachage et graphes. Des compétences essentielles pour les développeurs qui travaillent sur des projets systèmes ou embarqués exigeants.

Public visé

Développeurs C souhaitant approfondir leurs compétences.

Prérequis

Avoir suivi cette formation, ou en maîtriser les thèmes abordés :

C - Initiation

Objectifs pédagogiques

À l’issue de cette formation, vous serez capable de :

Maîtriser la gestion avancée de la mémoire et détecter les erreurs avec valgrind et les sanitizers
Déboguer efficacement avec gdb et mesurer la couverture de code
Écrire des tests unitaires en C
Utiliser les fonctionnalités de concurrence de C11 avec threads et atomics
Organiser un projet en modules avec Makefile, bibliothèques statiques et dynamiques
Optimiser les performances et profiler le code
Implémenter des structures de données avancées
Utiliser un assistant IA pour produire et relire du code C avancé de façon critique

Programme

Jour 1

Mémoire, pointeurs et débogage

Norme et environnement

situer le code parmi les normes — choix de C17
compiler en mode strict — -Wall, -Wextra, -Wpedantic, -Wshadow, -Wconversion
exploiter les spécificités utiles de GCC et Clang

Travaux pratiques :

Compiler un même module sous GCC et Clang en mode strict, comparer warnings et performances

Gestion avancée de la mémoire

allouer dynamiquement avec aligned_alloc en plus des classiques
choisir un pattern d’allocation selon le besoin — pool, arena, slab
détecter fuites et erreurs — valgrind, AddressSanitizer, UndefinedBehaviorSanitizer
gérer alignement et padding — _Alignof, _Alignas

Travaux pratiques :

Implémenter une arena allocator et la valider sous valgrind et AddressSanitizer

Pointeurs avancés

maîtriser l’arithmétique des pointeurs et l’optimisation restrict
exploiter les pointeurs de pointeurs pour les structures dynamiques
concevoir des callbacks via pointeurs sur fonctions
programmer génériquement avec void * et _Generic

Travaux pratiques :

Construire un conteneur générique de type vecteur de T paramétré par _Generic

Débogage interactif

piloter une session gdb avec breakpoints et watchpoints
mesurer la couverture de code — gcov, lcov

Travaux pratiques :

Diagnostiquer un programme bogué sous gdb puis mesurer sa couverture après ajout de tests

Jour 2

Modularité, tests et concurrence

Programmation modulaire

organiser le code en modules cohérents
structurer les en-têtes avec include guards et prototypes
automatiser le build avec Makefile
distribuer du code en bibliothèque statique .a ou dynamique .so
intégrer des dépendances avec pkg-config

Travaux pratiques :

Découper un projet en bibliothèque statique et exécutable consommateur, avec Makefile complet

Préprocesseur avancé

composer des macros avec paramètres et opérateurs #, ##
écrire des macros variadiques
gérer la compilation conditionnelle et la feature detection
exploiter le préprocesseur pour le debug avec logs conditionnels

Travaux pratiques :

Mettre en place un système de logs paramétrable par macro avec niveaux et compilation conditionnelle

Tests unitaires

choisir un framework — Unity, Check, CUnit
organiser les tests avec fixtures et assertions
intégrer la suite de tests dans le Makefile et la CI

Travaux pratiques :

Ajouter une suite Unity à un module existant et l’intégrer en cible Makefile

Concurrence en C11

créer et synchroniser des threads avec <threads.h>
exploiter les opérations atomiques avec <stdatomic.h>
détecter les data races avec ThreadSanitizer
éviter les pièges classiques de data races et deadlocks

Travaux pratiques :

Implémenter un producteur/consommateur thread-safe et le valider sous ThreadSanitizer

Jour 3

Structures de données, qualité et IA

Structures de données avancées

implémenter un arbre binaire puis un arbre équilibré
construire une table de hachage
modéliser un graphe et ses parcours
choisir la structure selon le profil d’accès

Travaux pratiques :

Mesurer comparativement les performances d’une recherche sur arbre et sur table de hachage

Optimisation et bonnes pratiques

profiler le code — perf, gprof, callgrind
arbitrer entre optimisation algorithmique et flags compilateur — -O2, -O3, LTO
écrire du code portable face à l’endianness et aux tailles de types
compléter par l’analyse statique — cppcheck, clang-tidy, scan-build
adopter une norme de codage — MISRA, CERT C

Travaux pratiques :

Profiler un programme avec perf, identifier le hotspot et appliquer une optimisation algorithmique

C et IA

identifier les cas d’usage avancés
repérer les limites en C avancé — APIs hallucinées, sanitizers non simulés, UB silencieux
formuler des prompts efficaces
vérifier systématiquement — compilation stricte, sanitizers, valgrind, tests

Travaux pratiques :

Projet final : structure de données complexe avec tests unitaires, profilage, exécution sous sanitizers, et relecture assistée par IA

Modalités d’évaluation des acquis

En cours de formation, par des études de cas ou des travaux pratiques. En fin de formation, par un questionnaire d’auto-évaluation.

Voir aussi

Vous serez peut-être intéressés par les formations suivantes :

Formation DEV-C-200 — C - Avancé. Domaine : Développement. Niveau : Intermédiaire. Durée : 3 jours (21 heures). Mots-clés : c, développement, avancé, mémoire, pointeurs, optimisation. Cylian Formation, Dijon.