Formation C++ Perfectionnement : conception avancée et design patterns

– Construction, initialisation et composition d’objets : durée de vie et classes de stockage
– Constance et `mutable` : garantir l’immuabilité logique d’un objet
– Contrôle d’accès, amitié et membres statiques : rappels ciblés sur l’encapsulation
– Écriture actuelle du langage : `auto`, boucle `for` sur intervalle, `nullptr`, `enum class` et initialisation uniforme
– Fonctions membres spéciales : `= default`, `= delete`, délégation de constructeurs, `override` et `final`
– Espaces de noms : organisation du code et résolution des noms

– Pointeurs et références : pièges courants (fuites, pointeurs pendants, débordements de tableaux)
– Forme canonique d’une classe : constructeur de copie, affectation, destructeur et règles de trois, cinq et zéro
– RAII et pointeurs intelligents : `unique_ptr`, `shared_ptr`, `weak_ptr`, `make_unique` / `make_shared` et destructeur personnalisé
– Références rvalue et sémantique de déplacement : constructeur et affectation par déplacement, `std::move`
– Transmission parfaite et élision de copie : `std::forward` et optimisation du retour de valeur (RVO)
– Détection des erreurs mémoire : sanitizers et Valgrind pour traquer fuites et accès invalides

– Opérateurs binaires et unaires : arithmétique, comparaison, affectation, indexation `[]` et flux `<>`
– Incrément et décrément : formes préfixée et postfixée
– Opérateurs d’indirection `*` et `->` : proxies et pointeurs intelligents maison
– Foncteurs : objets fonctions, opérateur `()` et foncteurs de la bibliothèque standard
– Appelables : pointeurs de fonction, pointeurs sur membres et `std::function`
– Expressions lambda : syntaxe, modes de capture et lambdas génériques

– Opérateurs de conversion et constructions implicites : contrôler les conversions avec `explicit`
– Opérateurs de cast : `const_cast`, `static_cast`, `reinterpret_cast`, rôle, usages légitimes et pièges
– `dynamic_cast` : contrôle du downcasting dans une hiérarchie polymorphe
– RTTI : identification du type à l’exécution avec `typeid` et `type_info`

– Héritage ou composition : choisir la relation adaptée au besoin
– Héritage privé et protégé : réutiliser une implémentation, exportation de membres avec `using`
– Héritage multiple : collisions de membres et leur résolution
– Héritage en losange et héritage virtuel : partager une base commune
– Classes abstraites et interfaces : méthodes virtuelles pures et destructeur virtuel
– Principes de conception : substitution de Liskov, ouverture/fermeture et inversion des dépendances

– Templates de fonctions et de classes : instanciation implicite et explicite, paramètres par défaut
– Spécialisation partielle et totale : adapter un template à des types particuliers, surcharge de templates
– Templates variadiques et `static_assert` : nombre variable de paramètres, vérifications à la compilation
– Concepts : contraindre les paramètres d’un template et obtenir des messages d’erreur lisibles
– Idiomes de la programmation générique : traits, policy et CRTP
– Méta-programmation et `constexpr` : déplacer des calculs à la compilation

– Conteneurs séquentiels, associatifs et non ordonnés : `array`, `vector`, `list`, `forward_list`, `map`, `unordered_map`, critères de choix et complexité
– Itérateurs et adaptateurs : catégories d’itérateurs, adaptateurs de conteneurs et d’itérateurs
– Algorithmes : non mutants, mutants, tri et numériques, paramétrés par des lambdas
– Chaînes et flux : `string`, flux de fichiers et flux en mémoire
– Types utilitaires : `pair`, `tuple`, `optional` et `variant`

– Traitement des erreurs : `try`, `throw`, `catch` et ses variantes, traitement sur place ou propagation
– Hiérarchie des exceptions standard et classes d’exception applicatives
– Remontée de la pile et RAII : destruction des objets lors de la propagation d’une exception
– Garanties d’exception : garantie de base, garantie forte et `noexcept`
– Erreurs non traitées et transmission : `std::terminate` et `exception_ptr`
– Bonnes pratiques : C++ Core Guidelines et analyse statique du code

– Threads : `std::thread`, lancement, passage de paramètres, `join` et `detach`
– Exclusion mutuelle : `mutex`, `lock_guard` et `unique_lock`
– Variables conditionnelles : synchroniser producteurs et consommateurs
– Tâches asynchrones : `async`, `future` et `promise`
– Variables atomiques et `thread_local` : partager ou isoler des données entre threads