Programme de la formation
C++ Expert : Maîtrisez les Avancées du Langage (C++11 à C++20)

• C++11 : Fondations modernes et sémantique de déplacement

  - Introduction aux standards C++ modernes (11, 14, 17, 20)
  - Le modèle de sémantique de déplacement (rvalue references, move constructor, move assignment)
  - `auto` et déduction de type : principes et bonnes pratiques

• C++11 : Lambdas, Smart Pointers et Concurrence basique

  - Expressions lambda : syntaxe, captures, cas d'usage avancés
  - Pointeurs intelligents (`std::unique_ptr`, `std::shared_ptr`, `std::weak_ptr`)
  - Introduction à la concurrence C++11 (`std::thread`, `std::mutex`, `std::async`)

• C++14 : Simplifications et améliorations du langage

  - Généralisation de la déduction de type pour les fonctions (`auto` en retour, generic lambdas)
  - Variables et fonctions templates avec `auto`
  - Nouveautés des pointeurs intelligents et `std::make_unique`

• C++17 : Structure et utilisation du code moderne

  - `if constexpr` et `static_assert` pour la compilation conditionnelle
  - `std::optional`, `std::variant`, `std::any` pour gestion des valeurs diverses
  - `structured bindings` : décomposition d'objets, tableaux, paires

• C++17 : Algorithmes et fichiers

  - Améliorations des algorithmes standards (parallélisation, nouveaux algorithmes)
  - `std::filesystem` : manipulation de chemins et d'opérations sur les fichiers
  - Démonstration d'application des nouvelles fonctionnalités C++17

• C++20 : Concepts et programmation générique avancée

  - Les Concepts : définition, utilisation, contraintes sur les templates
  - Améliorations des templates : auto-template parameters, pack expansion
  - Application des Concepts pour un code générique plus sûr et lisible

• C++20 : Espaces de noms, Modules et Coroutines

  - Amélioration de la gestion des namespaces (inline namespaces, using declaration)
  - Introduction aux Modules : bénéfices, syntaxe, migration
  - Principes des Coroutines : `co_await`, `co_yield`, `co_return`

• C++20 : Ranges et vues pour conteneurs

  - `std::ranges` : philosophie et avantages des vues et adaptateurs
  - Utilisation des vues : `filter`, `transform`, `join`, `take`
  - Chaînage de vues pour des traitements de données efficaces

• C++20 : Concurrence avancée et synchronisation

  - Nouveautés de `std::thread`, `std::jthread` (joinable threads)
  - Atomics et synchronisation avancée : `std::atomic_ref`, `std::latch`, `std::barrier`
  - Modèle de mémoire C++ et ordre des opérations concurrentes

• Trucs et astuces C++ modernes : Optimisation et bonnes pratiques

  - Conseils pour l'optimisation des performances avec les fonctionnalités modernes
  - Refactoring de code existant vers C++11-C++20
  - Techniques de débogage et de profiling adaptées

• Meta-programmation C++ moderne

  - Meta-programmation par template : récursivité, SFINAE
  - Utilisation de `constexpr` et `consteval` pour calculs à la compilation
  - Exemples avancés de techniques de méta-programmation

• Cas pratiques et projets C++ modernes

  - Étude de cas concrets utilisant les spécificités de C++11 à C++20
  - Problèmes de conception et d'implémentation avancés
  - Q&A ouverte et discussion sur les évolutions futures du C++