Objectifs du cours
Le C++ reste stratégique pour les systèmes critiques, l’embarqué, la 3D ou la finance, mais la robustesse se joue dans les détails d’implémentation : RAII, ownership explicite, sémantique de copie/déplacement, STL et outillage. Cette formation pose un socle professionnel : code maintenable, testable et outillé (CMake, formatage, analyzers/sanitizers). On traite la gestion mémoire moderne (smart pointers, règle de 5), la STL utile (conteneurs et algorithmes), les APIs standard récentes (string_view, span, filesystem) et une politique d’erreurs lisible (exceptions vs retours de valeur, aperçu std::expected). Les ateliers s’appuient sur des cas réalistes (structures de données, parsing, fichiers, perfs raisonnables) pour ancrer des réflexes durables. Objectif : des livrables C++ production-ready.
Résultat : des premiers programmes lisibles et maintenables, moins d’écueils, et une courbe d’apprentissage sous contrôle.
Les participants apprendront à :
- Structurer des projets C++ : séparation .h/.cpp, dépendances minimales, CMake Debug/Release.
- Concevoir en POO propre : encapsulation, constructeurs/destructeurs, héritage/polymorphisme (avec destructeur virtuel).
- Appliquer RAII et ownership : std::unique_ptr/std::shared_ptr, règle de 5, move semantics.
- Exploiter la STL complète : conteneurs, itérateurs, algorithmes ; std::string_view, std::span, std::filesystem.
- Définir une politique d’erreurs : exceptions ciblées vs valeurs de retour (aperçu std::expected C++23).
- Outiller la qualité : tests unitaires (Catch2/GTest), sanitizers (ASan/UBSan), clang-format/clang-tidy.
- Livrer un projet fil rouge compilant sans warnings, testé et instrumenté.
Public
-
Développeurs amenés à concevoir, maintenir ou optimiser des applications C++ en contexte professionnel.
Prérequis
-
Bases de programmation (ou C/C++) et aisance avec un environnement de compilation et le terminal.
Contenu du cours
Jour 1 — Architecture, build & rappels utiles
- Anatomie d’un projet : .h/.cpp, include guards, forward declarations, dépendances minimales.
- CMake : structure, options, profils Debug/Release, flags de compilation et warnings.
- Rappels C → C++ : références, surcharges basiques, espaces de noms, constexpr/inline (bon usage).
- Atelier (pertinent) : création d’un projet CMake, compilation sur deux profils, nettoyage des warnings.
Jour 2 — POO solide & sémantique d’objet
- Classes : invariants, initialisation des membres, membres statiques, séparation interface/implémentation.
- Héritage & polymorphisme : classes abstraites, destructeur virtuel, règles de conception (préférer composition).
- Sémantique de copie/déplacement : règle de 5 (ctor/assign copie/déplacement + dtor), cohérence état/ressources.
- Atelier (pertinent) : refactor d’une classe propriétaire de ressources (copie → move), tests de comportement.
Jour 3 — Mémoire moderne & RAII
- Ownership explicite : quand unique_ptr vs shared_ptr, make_unique, cycles et weak_ptr.
- RAII : gestion de ressources (fichiers/verrous/connexions), paliers d’exceptions, strong/weak exception safety.
- Pointeurs/références : aliasing, pièges (dangling), conventions de signature (in/out).
- Atelier (pertinent) : transformation d’un code à pointeurs bruts en RAII + smart pointers, validation avec ASan.
Jour 4 — STL utile & APIs standard récentes
- Conteneurs : vector, string, map/unordered_map, deque ; critères de choix et complexité.
- Algorithmes : sort, find, transform, accumulate, remove_if ; itérateurs & prédicats (lambdas).
- APIs modernes : std::string_view (éviter les copies), std::span (vues sur séquences), std::filesystem (chemins/itérations).
- I/O moderne : std::format vs iostream ; gestion des locales (aperçu).
- Atelier (pertinent) : pipeline de traitement (lecture fichiers → transformation STL → export), mesures simples.
Jour 5 — Erreurs, tests, diagnostics & projet fil rouge
- Politique d’erreurs : exceptions ciblées (types, niveaux), alternatives (retours de valeur), aperçu std::expected.
- Qualité & diagnostics : tests unitaires (Catch2/GTest), sanitizers (ASan/UBSan), clang-tidy, logs légers.
- Packaging : arborescence finale, options de build, documentation courte (README technique).
- Projet fil rouge : application console intégrant POO + RAII + STL + fichiers + tests ; démo + check ASan.