C++ - Perfectionnement

Objectifs du cours

En production, la qualité du C++ se joue dans la gestion des ressources, la sémantique d’objet et l’usage efficace de la STL — bien plus que dans la syntaxe. Cette session consolide vos bases et les aligne sur des pratiques modernes (RAII, smart pointers, move semantics, algorithmes STL/ranges) pour livrer un code prévisible, testable et maintenable. On clarifie la politique d’erreurs (exceptions vs retours de valeur) et on outille le pipeline (CMake, tests, sanitizers) afin de réduire les régressions et accélérer les revues de code. L’objectif : augmenter la vitesse de livraison sans dette technique cachée, sur des bases solides et durables.  

À l’issue de la formation, les participantes seront capables de :

• Renforcer les fondamentaux “production-ready” (organisation, const-correctness, sémantique d’objet).
• Maîtriser passage d’arguments, copie/déplacement (règle de 5) et gestion mémoire moderne (RAII, smart pointers).
• Approfondir la POO avancée (polymorphisme robuste, override/final, préférence composition).
• Déployer la programmation générique (templates, déduction, constexpr, concepts C++20 en introduction).
• Exploiter efficacement la STL (conteneurs, itérateurs, algorithmes) et les APIs récentes (string_view, span, filesystem, format).
• Structurer une politique d’erreurs claire (exceptions vs alternatives) et professionnaliser l’outillage (CMake, tests, sanitizers).

Public

• Développeurs C++ expérimentés
• Étudiants avancés en développement logiciel
• Professionnels souhaitant consolider leur expertise C++

Prérequis

• Connaissances solides des bases du langage C++.

Contenu du cours

Partie 1 : Renforcement des bases

• Rappels de syntaxe ; tableaux C vs std::array et std::vector (choix & implications).
• Définition de classes, constructeurs, destructeurs ; initialisation des membres.
• Accès aux membres (private, public) ; const-correctness (notion).
• Méthodes d’instance et static ; séparation headers/implémentations ; CMake minimal.
• Surcharge de fonctions, paramètres par défaut (bonnes pratiques).
  Exercice : passer un petit projet sous CMake, consolider l’API (const, en-têtes propres).

Partie 2 : Passage d’arguments et gestion mémoire

• Passage par valeur, par référence (const&), par adresse : coûts et intentions.
• Constructeur de copie et opérateur d’affectation ; introduction move semantics (vue d’ensemble).
• Méthodes const, membres static (rappels) ; layout mémoire (pile/tas) & implications simples.
  Exercice : comparer plusieurs signatures (valeur, const&, move) sur une même fonction.

Partie 3 : Programmation orientée objet avancée

• Héritage (public, protected, private) ; destructeur virtuel, slicing (à éviter).
• Surcharge vs redéfinition ; override/final pour sécuriser le polymorphisme.
• Polymorphisme, méthodes virtuelles, classes abstraites ; préférer composition quand c’est possible.
• Manipulation des sous-classes ; héritage multiple : usages ciblés & précautions.
  Exercice : concevoir une mini-hiérarchie robuste (interface + implémentations), tests de comportement.

Partie 4 : Smart pointers et gestion des ressources

• Dangers des pointeurs nus (fuites, double free, ownership flou).
• Introduction RAII et gestion automatique de la mémoire.
• std::unique_ptr, std::shared_ptr, std::weak_ptr (C++11+) ; make_unique, deleters personnalisés.
• Pourquoi abandon de auto_ptr ; quand éviter shared_ptr.
  Exercice : refactor d’un module à pointeurs bruts → RAII + unique_ptr ; vérification ASan.

Partie 5 : Gestion des erreurs avec les exceptions

• Principe, taxonomie minimale ; lignes rouges (pas d’exception pour le flux normal).
• try/catch, propagation, noexcept en pratique ; niveaux de garantie (basic/strong).
• Classes d’exception personnalisées : intérêt réel & parcimonie.
• Alternatives : codes de retour, std::optional, aperçu std::expected (C++23).
  Exercice : décliner deux politiques d’erreurs sur un même cas (exceptions vs retour de valeur).

Partie 6 : Programmation générique avec les templates

• Templates de fonctions et de classes : syntaxe, instanciation ; CTAD (déduction guide).
• Paramètres de modèles, variadic templates, forwarding parfait (std::forward, std::move).
• constexpr (évaluation compile-time) ; de SFINAE à concepts (C++20) : requires (introduction).
• Avantages/limites de la généricité ; lisibilité et diagnostics.
  Exercice : écrire une fonction template contrainte par un requires simple.

Partie 7 : Standard Template Library (STL)

• Conteneurs : vector, list, map/unordered_map, deque (critères de choix, complexité).
• Itérateurs & parcours ; algorithmes standards : sort, find, transform, accumulate, remove_if.
• Ranges (C++20) : vues filter/transform/take (introduction) pour des pipelines lisibles.
• APIs modernes : std::string_view, std::span, std::filesystem, std::format.
• I/O : flux vs format ; implications perfs et lisibilité.
  Exercice : pipeline fichiers → transformations STL/ranges → export ; micro-mesures (chrono).