SOMMAIRE.md

📘 Table des Matières - Maîtriser C++ Moderne sur Ubuntu

Formation Complète Développeurs & DevOps — Débutant → Expert

Édition 2026 — Cloud Native & System Programming

---

PARTIE I : FONDATIONS

---

Module 1 : L'Environnement de Développement sur Linux (Niveau Débutant)

1. Introduction au C++ et à l'écosystème Linux

• 1.1 Histoire et évolution du C++ (C++98 → C++26)
• 1.2 Pourquoi C++ pour le DevOps et le System Programming
• 1.3 Le cycle de compilation : Préprocesseur → Compilateur → Assembleur → Linker
  • 1.3.1 Le préprocesseur : #include, #define, macros
  • 1.3.2 La compilation : Génération du code objet
  • 1.3.3 L'édition de liens : Résolution des symboles
• 1.4 Anatomie d'un exécutable ELF sur Linux
  • 1.4.1 Structure du format ELF (headers, sections, segments)
  • 1.4.2 Inspection avec readelf et objdump

2. Mise en place de la Toolchain sur Ubuntu

• 2.1 Installation des compilateurs : GCC (g++) et LLVM (clang++)
  • 2.1.1 Gestion des versions avec update-alternatives
  • 2.1.2 Comparaison GCC vs Clang : Avantages et inconvénients
  • 2.1.3 État 2026 : GCC 15 et Clang 20 — Nouveautés et support C++26 🔥
• 2.2 Les outils essentiels : build-essential, gdb, make, ninja-build, cmake
• 2.3 Accélération de compilation : ccache (Compiler Cache) ⭐
  • 2.3.1 Installation et configuration de ccache
  • 2.3.2 Intégration avec CMake et Makefiles
  • 2.3.3 Statistiques et monitoring du cache
• 2.4 Configuration de l'IDE : VS Code, CLion, Vim/Neovim
  • 2.4.1 Extensions VS Code essentielles (C/C++, CMake Tools, clangd)
  • 2.4.2 Configuration du debugging intégré
  • 2.4.3 DevContainers : Environnement reproductible
  • 2.4.4 IA-assisted tooling : Copilot, Clangd AI et completion intelligente (2026) ⭐
• 2.5 Premier programme : Compilation manuelle et analyse
  • 2.5.1 Compilation étape par étape (g++ -E, -S, -c)
  • 2.5.2 Inspection des binaires (nm, objdump, ldd)
  • 2.5.3 Dépendances dynamiques et résolution
• 2.6 Options de compilation critiques
  • 2.6.1 Warnings : -Wall, -Wextra, -Wpedantic, -Werror
  • 2.6.2 Optimisation : -O0, -O2, -O3, -Os
  • 2.6.3 Debug : -g, -ggdb3
  • 2.6.4 Standard : -std=c++17, -std=c++20, -std=c++23, -std=c++26
• 2.7 Introduction à std::print (C++23) : Le nouveau standard d'affichage ⭐
  • 2.7.1 Syntaxe et comparaison avec std::cout et printf
  • 2.7.2 Formatage type-safe et performant
  • 2.7.3 État du support compilateur (GCC 15+, Clang 19+)

💡 La section 2.7 est une prise en main rapide de std::print pour les débutants. La couverture approfondie du système de formatage se trouve en section 12.7 (std::print et std::format).

---

Module 2 : Les Fondamentaux du Langage (Niveau Débutant)

3. Types, Variables et Opérateurs

• 3.1 Le typage statique fort et l'inférence de type
  • 3.1.1 auto : Déduction automatique du type
  • 3.1.2 decltype : Extraction du type d'une expression
  • 3.1.3 Quand utiliser auto vs type explicite
• 3.2 Types primitifs, tailles et représentation mémoire
  • 3.2.1 Entiers : int, long, short, int32_t, int64_t
  • 3.2.2 Flottants : float, double, long double
  • 3.2.3 sizeof et alignof : Taille et alignement
• 3.3 Conversion de types : Cast implicite vs explicite
  • 3.3.1 static_cast : Conversions sûres
  • 3.3.2 reinterpret_cast : Réinterprétation mémoire
  • 3.3.3 const_cast : Manipulation de const
  • 3.3.4 dynamic_cast : Cast polymorphique
• 3.4 Portée des variables (Scope) et durée de vie (Lifetime)
• 3.5 const, constexpr et consteval (C++20)
  • 3.5.1 const : Immutabilité à l'exécution
  • 3.5.2 constexpr : Calcul à la compilation
  • 3.5.3 consteval : Fonctions obligatoirement compile-time

4. Structures de Contrôle et Fonctions

• 4.1 Conditionnelles et boucles
  • 4.1.1 if, else if, else et if constexpr
  • 4.1.2 switch et switch avec initialisation (C++17)
  • 4.1.3 Range-based for loop
• 4.2 Déclaration et définition de fonctions
• 4.3 Passage de paramètres
  • 4.3.1 Par valeur
  • 4.3.2 Par référence (&)
  • 4.3.3 Par référence constante (const &)
  • 4.3.4 Par pointeur (*)
• 4.4 Surcharge de fonctions (Function Overloading)
• 4.5 Valeurs par défaut et fonctions inline

5. Gestion de la Mémoire (Le cœur du sujet)

• 5.1 Comprendre la Stack (Pile) vs le Heap (Tas)
  • 5.1.1 Diagramme mémoire d'un processus
  • 5.1.2 Caractéristiques de la Stack
  • 5.1.3 Caractéristiques du Heap
• 5.2 Allocation dynamique : new/delete, new[]/delete[]
• 5.3 Arithmétique des pointeurs et accès bas niveau
• 5.4 Dangers : Memory leaks, dangling pointers, double free
• 5.5 Outils de détection : Valgrind, AddressSanitizer
  • 5.5.1 Valgrind : Installation et utilisation
  • 5.5.2 AddressSanitizer : Compilation avec -fsanitize=address

---

Module 3 : Programmation Orientée Objet (Niveau Débutant-Intermédiaire)

6. Classes et Encapsulation

• 6.1 Définition de classes : Membres et méthodes
• 6.2 Constructeurs
  • 6.2.1 Constructeur par défaut
  • 6.2.2 Constructeur paramétré
  • 6.2.3 Constructeur de copie
  • 6.2.4 Constructeur de déplacement
  • 6.2.5 Liste d'initialisation
• 6.3 Destructeurs et le principe RAII
  • 6.3.1 Resource Acquisition Is Initialization
  • 6.3.2 Exemples pratiques de RAII
• 6.4 Modificateurs d'accès : public, private, protected
• 6.5 La règle des 5 (Rule of Five) ⭐
  • 6.5.1 Destructeur
  • 6.5.2 Constructeur de copie
  • 6.5.3 Opérateur d'affectation par copie
  • 6.5.4 Constructeur de déplacement
  • 6.5.5 Opérateur d'affectation par déplacement

7. Héritage et Polymorphisme

• 7.1 Héritage simple et multiple
  • 7.1.1 Héritage simple
  • 7.1.2 Héritage multiple et problème du diamant
  • 7.1.3 Héritage virtuel
• 7.2 Fonctions virtuelles et mécanisme de vtable
• 7.3 Polymorphisme dynamique : virtual, override, final
• 7.4 Classes abstraites et interfaces pures
• 7.5 Coût du polymorphisme dynamique en performance

8. Surcharge d'Opérateurs et Conversions

• 8.1 Surcharge des opérateurs arithmétiques et de comparaison
• 8.2 Opérateurs d'affectation (= et +=, -=, etc.)
• 8.3 Opérateurs de conversion (conversion operators)
• 8.4 Opérateur d'appel de fonction (operator())
• 8.5 Opérateur spaceship <=> (C++20)

---

PARTIE II : C++ MODERNE

---

Module 4 : C++ Moderne (C++11 → C++26) (Niveau Intermédiaire)

9. Smart Pointers : Gestion Automatique de la Mémoire ⭐

• 9.1 std::unique_ptr : Possession exclusive
  • 9.1.1 Création et utilisation
  • 9.1.2 Transfert de propriété avec std::move
  • 9.1.3 Custom deleters
• 9.2 std::shared_ptr et std::weak_ptr
  • 9.2.1 Comptage de références
  • 9.2.2 Cycles de références et std::weak_ptr
• 9.3 std::make_unique et std::make_shared
• 9.4 Ne jamais utiliser new/delete dans du code moderne 🔥

10. Sémantique de Mouvement (Move Semantics) ⭐

• 10.1 L-values vs R-values (&&)
• 10.2 std::move : Transfert de propriété sans copie
• 10.3 Move constructors et move assignment operators
• 10.4 Perfect Forwarding avec std::forward
• 10.5 Return Value Optimization (RVO) et Copy Elision

11. Programmation Fonctionnelle et Lambdas

• 11.1 Syntaxe des lambdas et types de captures
  • 11.1.1 Capture par valeur [=]
  • 11.1.2 Capture par référence [&]
  • 11.1.3 Capture de this
  • 11.1.4 Captures mixtes et init captures
• 11.2 Lambdas génériques (C++14) et templated lambdas
• 11.3 Utilisation avec les algorithmes STL
• 11.4 std::function et callable objects

12. Nouveautés C++17/C++20/C++23/C++26 ⭐

• 12.1 Structured Bindings (C++17)
• 12.2 std::optional, std::variant, std::any (C++17)
• 12.3 std::span (C++20) : Vue sur données contiguës

📎 Aperçu introductif. Pour la couverture détaillée et les cas d'usage, voir section 13.5 (std::span).

• 12.4 Concepts (C++20) : Contraintes sur les templates
• 12.5 Ranges (C++20) : Pipelines fonctionnels
• 12.6 Coroutines (C++20) : Programmation asynchrone
• 12.7 std::print et std::format (C++23) : Formatage moderne ⭐

💡 Couverture approfondie du système de formatage. Pour la prise en main rapide, voir section 2.7 (introduction à std::print).

• 12.8 std::expected (C++23) : Gestion d'erreurs sans exceptions ⭐
• 12.9 std::flat_map et std::flat_set (C++23) : Conteneurs ordonnés à mémoire contiguë ⭐
  • 12.9.1 Avantages performance vs std::map
  • 12.9.2 Cas d'usage et limites
• 12.10 std::mdspan (C++23) : Vues multidimensionnelles ⭐
• 12.11 std::generator (C++23) : Coroutines simplifiées
• 12.12 std::stacktrace (C++23) : Traces d'exécution standard
• 12.13 Modules (C++20) : Concept et état en 2026
  • 12.13.1 Avantages des modules sur les headers
  • 12.13.2 État du support (GCC 15, Clang 20, MSVC)
  • 12.13.3 Maturité en 2026 : Ce qui fonctionne, ce qui reste limité
• 12.14 C++26 : Les grandes nouveautés (en ratification) 🔥
  • 12.14.1 Contrats (Contracts) : Préconditions, postconditions, assertions
  • 12.14.2 Réflexion statique (Static Reflection)
  • 12.14.3 Pattern Matching : inspect et is
  • 12.14.4 std::execution (Senders/Receivers) : Asynchronisme standardisé — intégré C++26 🔥 (promu)
    • 12.14.4.1 Modèle Sender/Receiver : Concepts fondamentaux
    • 12.14.4.2 Remplacement de std::async et std::future
    • 12.14.4.3 Intégration avec les schedulers et thread pools
  • 12.14.5 Support compilateur C++26 : GCC 15 / Clang 20 — État mars 2026

---

Module 5 : La Librairie Standard (STL) (Niveau Intermédiaire)

13. Conteneurs Séquentiels

• 13.1 std::vector : Le conteneur par défaut
  • 13.1.1 Fonctionnement interne et capacité
  • 13.1.2 Méthodes essentielles
  • 13.1.3 Invalidation des itérateurs
• 13.2 std::array : Tableaux de taille fixe
• 13.3 std::list et std::forward_list : Listes chaînées
• 13.4 std::deque : File double entrée
• 13.5 std::span : Vue sur données contiguës (zéro allocation) ⭐
  • 13.5.1 Span statique vs dynamique
  • 13.5.2 Remplacement des paramètres pointeur+taille
  • 13.5.3 Interopérabilité avec vector, array et C arrays
• 13.6 Complexité algorithmique (Big O) et choix du conteneur

14. Conteneurs Associatifs

• 14.1 std::map et std::multimap : Arbres binaires ordonnés
• 14.2 std::unordered_map : Tables de hachage
  • 14.2.1 Fonctionnement des hash tables
  • 14.2.2 Custom hash functions
• 14.3 std::set et std::unordered_set
• 14.4 std::flat_map et std::flat_set (C++23) : Alternatives cache-friendly ⭐
• 14.5 Comparaison de performances : ordered vs unordered vs flat

15. Algorithmes de la STL

• 15.1 Recherche : std::find, std::binary_search
• 15.2 Tri : std::sort, std::stable_sort
• 15.3 Transformation : std::transform, std::accumulate
• 15.4 Manipulation : std::copy, std::move, std::remove_if
• 15.5 Itérateurs : input, output, forward, bidirectional, random_access
• 15.6 Ranges (C++20) : Simplification des algorithmes ⭐
  • 15.6.1 Views et lazy evaluation
  • 15.6.2 Pipelines avec l'opérateur |
• 15.7 Algorithmes parallèles : std::execution policies ⭐
  • 15.7.1 Politiques d'exécution : seq, par, par_unseq, unseq
  • 15.7.2 Parallélisation de std::sort, std::transform, std::reduce
  • 15.7.3 Précautions et limitations pratiques

16. Templates et Métaprogrammation

• 16.1 Templates de fonctions
• 16.2 Templates de classes
• 16.3 Spécialisation partielle et totale
• 16.4 SFINAE (Substitution Failure Is Not An Error)
• 16.5 Variadic templates (C++11)
• 16.6 Concepts (C++20) pour contraindre les templates ⭐
  • 16.6.1 Syntaxe requires
  • 16.6.2 Concepts standard de la STL
  • 16.6.3 Création de concepts personnalisés
• 16.7 Fold expressions (C++17)

---

Module 6 : Gestion des Erreurs et Robustesse (Niveau Intermédiaire)

17. Exceptions et Gestion d'Erreurs

• 17.1 Syntaxe : try, catch, throw
• 17.2 Hiérarchie des exceptions standard (std::exception)
• 17.3 Exceptions personnalisées
• 17.4 noexcept et garanties d'exception
  • 17.4.1 Spécifier noexcept
  • 17.4.2 Impact sur les performances
• 17.5 Alternatives modernes : std::expected (C++23), codes d'erreur ⭐
• 17.6 Contrats (C++26) : Préconditions et postconditions — standard ratifié

📎 Introduction aux contrats dans le contexte de la gestion d'erreurs. Pour la couverture complète, voir section 12.14.1 (Contrats C++26).

18. Assertions et Débogage Défensif

• 18.1 assert et static_assert
• 18.2 Compilation conditionnelle (#ifdef DEBUG)
• 18.3 Logging et traces d'exécution
• 18.4 std::stacktrace (C++23) : Traces d'exécution standard

📎 Intégration de std::stacktrace dans le débogage. Voir aussi section 12.12 (std::stacktrace C++23).

---

PARTIE III : PROGRAMMATION SYSTÈME LINUX

---

Module 7 : Programmation Système sur Linux (Niveau Avancé)

19. Manipulation du Système de Fichiers

• 19.1 std::filesystem (C++17) : API moderne
  • 19.1.1 Parcours de répertoires
  • 19.1.2 Manipulation de chemins (path)
  • 19.1.3 Opérations sur fichiers et répertoires
• 19.2 Appels système POSIX : open, read, write, close
• 19.3 Comparaison : API C++ vs API système
• 19.4 Permissions, droits et gestion des erreurs

20. Signaux POSIX

• 20.1 Comprendre les signaux Unix (SIGINT, SIGTERM, SIGSEGV)
• 20.2 Installation de handlers (signal, sigaction)
• 20.3 Signaux et threads : Problématiques

21. Threads et Programmation Concurrente ⭐

• 21.1 std::thread : Création et gestion de threads
• 21.2 Synchronisation
  • 21.2.1 std::mutex
  • 21.2.2 std::lock_guard
  • 21.2.3 std::unique_lock
  • 21.2.4 std::scoped_lock (C++17)
• 21.3 Variables de condition : std::condition_variable
• 21.4 Atomiques : std::atomic et memory ordering
• 21.5 std::async et std::future : Programmation asynchrone
• 21.6 Thread-safety et data races
• 21.7 std::jthread (C++20) : Threads auto-stoppables ⭐
• 21.8 Algorithmes parallèles appliqués à la concurrence

📎 Mise en pratique des politiques d'exécution parallèle dans un contexte multi-thread. Voir section 15.7 (algorithmes parallèles — std::execution policies).

22. Networking et Communication ⭐

• 22.1 Sockets TCP/UDP : API POSIX
  • 22.1.1 Création de sockets
  • 22.1.2 bind, listen, accept, connect
  • 22.1.3 send, recv, sendto, recvfrom
• 22.2 Client/Serveur basique en C++
• 22.3 Multiplexage I/O et I/O asynchrone
  • 22.3.1 select et poll : Interfaces POSIX classiques
  • 22.3.2 epoll : Le standard Linux
  • 22.3.3 io_uring : I/O asynchrone haute performance (Linux 5.1+) 🔥
    • 22.3.3.1 Architecture : Submission Queue et Completion Queue
    • 22.3.3.2 liburing : Interface C/C++ simplifiée
    • 22.3.3.3 Cas d'usage : networking, fichiers, timeouts
  • 22.3.4 Comparaison : select vs poll vs epoll vs io_uring
• 22.4 Librairies réseau modernes
  • 22.4.1 Standalone Asio : Networking sans Boost
  • 22.4.2 Boost.Asio : Écosystème complet
  • 22.4.3 Quand choisir Asio standalone vs Boost.Asio
• 22.5 Clients HTTP : cpr (wrapper curl), cpp-httplib ⭐
• 22.6 gRPC et Protocol Buffers : RPC moderne haute performance 🔥
  • 22.6.1 Installation et configuration gRPC
  • 22.6.2 Définition de services avec .proto
  • 22.6.3 Génération de code et implémentation
  • 22.6.4 Streaming bidirectionnel

23. Processus et IPC (Inter-Process Communication)

• 23.1 fork, exec et gestion de processus
• 23.2 Pipes et communication inter-processus
• 23.3 Shared memory et mmap
• 23.4 Message queues POSIX

---

Module 8 : Parsing et Formats de Données (Niveau Avancé) ⭐

24. Sérialisation et Fichiers de Configuration 🔥

• 24.1 JSON : Lecture/Écriture avec nlohmann/json ⭐
  • 24.1.1 Installation et intégration
  • 24.1.2 Parsing de fichiers JSON
  • 24.1.3 Sérialisation d'objets C++
  • 24.1.4 Gestion des erreurs de parsing
• 24.2 YAML : Parsing avec yaml-cpp ⭐
  • 24.2.1 Lecture de fichiers de configuration
  • 24.2.2 Écriture YAML
• 24.3 TOML : Alternative moderne (toml++)
• 24.4 XML : Parsing avec pugixml (legacy systems)
• 24.5 Bonnes pratiques : Validation de schémas
• 24.6 Expressions régulières en C++ : std::regex et alternatives performantes ⭐
  • 24.6.1 std::regex : API standard et limites de performance
  • 24.6.2 CTRE : Compile-Time Regular Expressions (C++20) 🔥
  • 24.6.3 RE2 et PCRE2 : Alternatives runtime performantes
  • 24.6.4 Benchmarks et guide de choix

25. Formats Binaires et Sérialisation Performante

• 25.1 Protocol Buffers (Protobuf) : Sérialisation Google ⭐
  • 25.1.1 Définition de messages .proto
  • 25.1.2 Génération de code C++
  • 25.1.3 Sérialisation/Désérialisation
• 25.2 FlatBuffers : Zéro-copy serialization
• 25.3 Cap'n Proto : Zéro-copie sans étape d'encodage ⭐
  • 25.3.1 Philosophie : le format wire EST le format mémoire
  • 25.3.2 Schémas, génération de code et RPC intégré
  • 25.3.3 Cap'n Proto vs FlatBuffers vs Protobuf : compromis
• 25.4 MessagePack : JSON binaire compact
• 25.5 Comparaison de performances et cas d'usage

---

PARTIE IV : TOOLING ET BUILD SYSTEMS

---

Module 9 : Build Systems et Gestion de Projet (Niveau Avancé)

26. CMake : Le Standard de l'Industrie 🔥

• 26.1 Structure d'un projet CMake moderne
• 26.2 Écrire un CMakeLists.txt : targets, libraries, executables
  • 26.2.1 add_executable et add_library
  • 26.2.2 target_link_libraries
  • 26.2.3 target_include_directories
  • 26.2.4 PUBLIC, PRIVATE, INTERFACE
• 26.3 Gestion des dépendances et sous-répertoires
  • 26.3.1 find_package
  • 26.3.2 FetchContent
  • 26.3.3 add_subdirectory
• 26.4 Configuration et génération de fichiers
• 26.5 Génération pour Ninja : cmake -G Ninja (recommandé) ⭐
• 26.6 Toolchains et cross-compilation
• 26.7 CMake 3.31+ : Nouveautés et meilleures pratiques 2026 ⭐

27. Gestion des Dépendances ⭐

• 27.1 Le problème des librairies en C++
• 27.2 Conan 2.0 : Nouvelle API et conanfile.py 🔥
  • 27.2.1 Installation et configuration
  • 27.2.2 conanfile.py vs conanfile.txt
  • 27.2.3 Profils et settings
  • 27.2.4 Intégration CMake
• 27.3 vcpkg : Alternative Microsoft
• 27.4 Linkage statique (.a) vs dynamique (.so)
• 27.5 Installation et distribution de librairies sur Linux
• 27.6 CMake Presets : Standardisation des configurations ⭐

28. Makefile, Ninja et Build Automation

• 28.1 Syntaxe de base des Makefiles
• 28.2 Variables, règles et patterns
• 28.3 Ninja : Build system ultra-rapide ⭐
  • 28.3.1 Pourquoi Ninja est plus rapide
  • 28.3.2 Fichiers build.ninja
• 28.4 Meson : Build system montant dans l'écosystème Linux
  • 28.4.1 Syntaxe déclarative et philosophie
  • 28.4.2 Projets notables utilisant Meson (GNOME, systemd, Mesa)
• 28.5 Comparaison Make vs Ninja vs Meson : Performances et cas d'usage

---

Module 10 : Débogage, Profiling et Qualité Code (Niveau Avancé)

29. Débogage Avancé

• 29.1 GDB : Commandes essentielles et breakpoints
  • 29.1.1 Navigation : run, step, next, continue
  • 29.1.2 Inspection : print, display, watch
  • 29.1.3 Breakpoints conditionnels
• 29.2 Débogage via IDE (VS Code, CLion)
• 29.3 Core dumps et post-mortem debugging
• 29.4 Sanitizers
  • 29.4.1 AddressSanitizer (-fsanitize=address)
  • 29.4.2 UndefinedBehaviorSanitizer (-fsanitize=undefined)
  • 29.4.3 ThreadSanitizer (-fsanitize=thread)
  • 29.4.4 MemorySanitizer (-fsanitize=memory)
• 29.5 std::stacktrace : Traces d'exécution intégrées au débogage

30. Analyse Mémoire

• 30.1 Valgrind : Détection de fuites et erreurs mémoire
  • 30.1.1 memcheck : Détection de fuites
  • 30.1.2 Lecture des rapports Valgrind
• 30.2 Heap profiling avec Massif
• 30.3 Memory leaks : Détection et résolution

31. Profiling de Performance

• 31.1 perf : Profiling CPU et sampling
  • 31.1.1 perf record et perf report
  • 31.1.2 perf stat : Compteurs matériels
• 31.2 gprof : Profiling basé sur instrumentation
• 31.3 Flamegraphs et visualisation
• 31.4 Hotspot et outils graphiques

32. Analyse Statique et Linting

• 32.1 clang-tidy : Analyse statique moderne
  • 32.1.1 Configuration .clang-tidy
  • 32.1.2 Checks recommandés
• 32.2 cppcheck : Détection d'erreurs
• 32.3 clang-format 19 : Formatage automatique
• 32.4 Intégration dans le workflow de développement

---

Module 11 : Tests et Qualité Logicielle (Niveau Avancé)

33. Unit Testing avec Google Test ⭐

• 33.1 Installation et configuration de GTest
• 33.2 Écriture de tests : TEST, TEST_F, fixtures
  • 33.2.1 TEST : Tests simples
  • 33.2.2 TEST_F : Tests avec fixtures
  • 33.2.3 TEST_P : Tests paramétrés
• 33.3 Assertions et matchers
• 33.4 Mocking avec Google Mock
• 33.5 Test-Driven Development (TDD) en C++

34. Couverture de Code

• 34.1 gcov et lcov : Mesure de la couverture
• 34.2 Génération de rapports HTML
• 34.3 Intégration dans CMake
• 34.4 Objectifs de couverture

35. Benchmarking

• 35.1 Google Benchmark : Micro-benchmarking
• 35.2 Mesure de performance fiable
• 35.3 Interprétation des résultats

---

PARTIE V : DEVOPS ET CLOUD NATIVE

---

Module 12 : Création d'Outils CLI (Niveau Avancé) ⭐

36. Interfaces en Ligne de Commande Modernes 🔥

• 36.1 CLI11 : Parsing d'arguments professionnel ⭐
  • 36.1.1 Installation et premiers pas
  • 36.1.2 Options, flags et sous-commandes
  • 36.1.3 Validation et callbacks
  • 36.1.4 Génération d'aide automatique
• 36.2 argparse : Alternative légère
• 36.3 fmt : Formatage avancé (pré-C++23) ⭐
  • 36.3.1 Syntaxe Python-like
  • 36.3.2 Couleurs et styles
• 36.4 Gestion des couleurs et du TTY
• 36.5 Architecture d'un outil CLI professionnel (à la kubectl, git)

---

Module 13 : C++ dans une Approche DevOps (Niveau Avancé) 🔥

37. Dockerisation d'Applications C++

• 37.1 Création d'images Docker pour C++ (Ubuntu vs Alpine)
• 37.2 Multi-stage builds : Optimisation de la taille
  • 37.2.1 Stage de compilation
  • 37.2.2 Stage d'exécution minimal
• 37.3 Gestion des librairies partagées dans les conteneurs
• 37.4 Best practices : Sécurité et reproductibilité
• 37.5 Distroless images : Conteneurs minimaux ⭐

38. CI/CD pour C++ ⭐

• 38.1 Pipeline GitLab CI : Build → Test → Package
  • 38.1.1 Structure .gitlab-ci.yml
  • 38.1.2 Jobs et stages
• 38.2 GitHub Actions : Workflows pour C++
  • 38.2.1 Structure workflow YAML
  • 38.2.2 Actions utiles pour C++
• 38.3 Accélération CI : ccache et sccache (cache distribué) 🔥
  • 38.3.1 Configuration ccache en CI
  • 38.3.2 sccache : Cache distribué cloud
• 38.4 Automatisation : Tests, analyse statique, déploiement
• 38.5 Artifacts et gestion des releases
• 38.6 Cross-compilation : ARM, RISC-V depuis x86_64
• 38.7 Matrix builds : Multi-compilateur, multi-version ⭐

39. Packaging et Distribution

• 39.1 Création de paquets DEB (Debian/Ubuntu)
  • 39.1.1 Structure d'un paquet DEB
  • 39.1.2 Scripts de contrôle
  • 39.1.3 Construction avec dpkg-deb
• 39.2 Création de paquets RPM (RedHat/CentOS)
• 39.3 AppImage et distribution universelle
• 39.4 Distribution via gestionnaires de paquets (apt, snap)

40. Observabilité et Monitoring ⭐

• 40.1 Logging structuré : spdlog (recommandé) vs std::print 🔥
  • 40.1.1 Installation et configuration spdlog
  • 40.1.2 Niveaux de log et sinks
  • 40.1.3 Pattern de formatage
• 40.2 Métriques et instrumentation (Prometheus client)
• 40.3 Tracing distribué (OpenTelemetry C++)
• 40.4 Health checks et readiness probes
• 40.5 Structured logging : JSON logs pour agrégation ⭐

---

PARTIE VI : SUJETS AVANCÉS

---

Module 14 : Optimisation de Performance (Niveau Expert)

41. Optimisation CPU et Mémoire ⭐

• 41.1 Comprendre le cache CPU et la localité des données
  • 41.1.1 Cache L1, L2, L3
  • 41.1.2 Cache lines et false sharing
  • 41.1.3 Data-oriented design
• 41.2 Branch prediction et optimisation des conditions
• 41.3 SIMD et vectorisation (SSE, AVX)
  • 41.3.1 Intrinsics
  • 41.3.2 Auto-vectorisation du compilateur
• 41.4 Profile-Guided Optimization (PGO)
• 41.5 Link-Time Optimization (LTO)
• 41.6 std::flat_map/flat_set et performance cache

📎 Application des conteneurs flat dans un contexte d'optimisation. Voir section 14.4 (std::flat_map et std::flat_set C++23).

42. Programmation Bas Niveau

• 42.1 Inline assembly en C++
• 42.2 Manipulation de bits et bitfields
• 42.3 Memory ordering et barrières mémoire
• 42.4 Lock-free programming
  • 42.4.1 Structures lock-free
  • 42.4.2 Compare-and-swap (CAS)

---

Module 15 : Interopérabilité (Niveau Expert)

43. C++ et Autres Langages

• 43.1 C++ et C : extern "C" et ABI compatibility
• 43.2 Appeler du C++ depuis Python (pybind11) ⭐
  • 43.2.1 Installation et configuration
  • 43.2.2 Exposition de fonctions et classes
  • 43.2.3 Gestion des types et conversions
  • 43.2.4 nanobind : Alternative moderne et plus rapide
• 43.3 C++ et Rust : FFI et interopérabilité 🔥 (étendu)
  • 43.3.1 extern "C" et liaison manuelle
  • 43.3.2 cxx : Le bridge Rust↔C++ de référence ⭐
  • 43.3.3 autocxx : Bindings automatiques C++ → Rust
  • 43.3.4 Stratégie de migration progressive : quand et comment introduire Rust
  • 43.3.5 Cas d'usage et retours d'expérience industrie 2025-2026
• 43.4 WebAssembly : Compiler du C++ pour le web (Emscripten) ⭐
  • 43.4.1 Installation Emscripten
  • 43.4.2 Compilation et intégration JavaScript

---

Module 16 : Patterns et Architecture (Niveau Expert)

44. Patterns de Conception en C++

• 44.1 Singleton, Factory, Builder
  • 44.1.1 Singleton thread-safe
  • 44.1.2 Factory et Abstract Factory
  • 44.1.3 Builder fluent
• 44.2 Observer, Strategy, Command
• 44.3 CRTP (Curiously Recurring Template Pattern)
• 44.4 Type erasure et std::any
• 44.5 Dependency Injection en C++

45. Sécurité en C++ ⭐

• 45.1 Buffer overflows et protection
• 45.2 Integer overflows et underflows
• 45.3 Use-after-free et temporal safety
• 45.4 Compilation avec protections
  • 45.4.1 -fstack-protector
  • 45.4.2 -D_FORTIFY_SOURCE
  • 45.4.3 ASLR et PIE
• 45.5 Fuzzing avec AFL++, LibFuzzer ⭐
  • 45.5.1 Configuration AFL++
  • 45.5.2 LibFuzzer et intégration
• 45.6 Sécurité mémoire : Réponses concrètes du comité C++ en 2026 🔥
  • 45.6.1 Contexte réglementaire 2026 : NSA, CISA, Union Européenne et Cyber Resilience Act
  • 45.6.2 Safety Profiles : État de maturité et adoption en 2026 🔥
  • 45.6.3 Hardening avec les sanitizers en production
  • 45.6.4 Stratégie de migration progressive et interopérabilité Rust
  • 45.6.5 Bilan : C++ safe-by-default est-il atteignable ? (état 2026)

---

PARTIE VII : PROJET ET PROFESSIONNALISATION

---

Module 17 : Architecture de Projet Professionnel (Niveau Expert)

46. Organisation et Standards

• 46.1 Organisation des répertoires (src/, include/, tests/, docs/)
• 46.2 Séparation .h/.cpp et compilation incrémentale
• 46.3 Namespaces et éviter la pollution globale
• 46.4 Documentation : Doxygen et commentaires
  • 46.4.1 Syntaxe Doxygen
  • 46.4.2 Génération de documentation
• 46.5 Standards de codage
  • 46.5.1 Google C++ Style Guide
  • 46.5.2 LLVM Style
  • 46.5.3 C++ Core Guidelines

47. Collaboration et Maintenance ⭐

• 47.1 Git et workflows (GitFlow, trunk-based)
• 47.2 Pre-commit hooks : Automatisation de la qualité avant commit 🔥
  • 47.2.1 Installation du framework pre-commit
  • 47.2.2 Hooks essentiels pour C++
• 47.3 Configuration pre-commit : clang-format, clang-tidy, tests rapides 🔥
  • 47.3.1 .pre-commit-config.yaml
  • 47.3.2 Intégration clang-format
  • 47.3.3 Intégration clang-tidy
• 47.4 Code reviews efficaces
• 47.5 Gestion de la dette technique
• 47.6 Semantic Versioning et changelogs

48. Ressources et Veille Technologique

• 48.1 Livres de référence
  • 48.1.1 Effective C++ (Scott Meyers)
  • 48.1.2 C++ Concurrency in Action (Anthony Williams)
  • 48.1.3 A Tour of C++ (Bjarne Stroustrup)
  • 48.1.4 Embracing Modern C++ Safely (Lakos, Romeo, Khlebnikov, Meredith)
• 48.2 Conférences
  • 48.2.1 CppCon
  • 48.2.2 Meeting C++
  • 48.2.3 C++ Now
  • 48.2.4 ACCU Conference
• 48.3 Standards et évolutions futures (C++26 en ratification, cap sur C++29)
  • 48.3.1 Calendrier du comité ISO et processus de standardisation
  • 48.3.2 Suivre les proposals (open-std.org, GitHub)
  • 48.3.3 Premières proposals C++29 : Ce qui se prépare
• 48.4 Communautés et forums
  • 48.4.1 Stack Overflow
  • 48.4.2 Reddit r/cpp
  • 48.4.3 Discord C++
  • 48.4.4 Compiler Explorer (godbolt.org)

---

Conclusion

• Récapitulatif des compétences acquises
• Trajectoires professionnelles
  • System Programming
  • Backend haute performance
  • Embedded / IoT
  • Finance quantitative
  • DevOps / SRE
  • Game Development / Moteurs 3D
• Ressources pour aller plus loin
• Checklist du développeur C++ Cloud Native ⭐

---

📊 Métriques de la Formation

Métrique	Valeur
Parties	7
Modules	17
Chapitres	48
Sections	~305
Fichiers Markdown	~415
Durée estimée	120-170h
Niveau couvert	Débutant → Expert
Standards C++	C++11 → C++26 (en ratification)
Compilateurs couverts	GCC 15, Clang 20
Dernière mise à jour	Mars 2026

---

🔥 Légende

• ⭐ = Section importante / Best practice
• 🔥 = Section critique / Différenciateur professionnel
• 📎 = Renvoi vers une section liée (évite les doublons)
• 💡 = Note pédagogique

---