Les standards C++20 et C++23 transforment le langage : modules, concepts, ranges, coroutines, std::expected, parallélisme STL. Cette formation de mise à niveau de 3 jours permet aux développeurs C++ expérimentés de s’approprier ces nouveautés et de moderniser leur base de code existante avec l’aide d’un assistant IA.

Public visé

Développeurs C++.

Prérequis

Avoir suivi cette formation, ou en maîtriser les thèmes abordés :

C++ - Initiation

Objectifs pédagogiques

À l’issue de cette formation, vous serez capable de :

Identifier les apports de C++11 à C++23
Organiser un projet avec modules et CMake moderne
Exploiter concepts, ranges et std::expected
Écrire des coroutines et tirer parti du parallélisme STL
Moderniser une base de code legacy avec clang-tidy et un assistant IA

Programme

Jour 1 - Matin

Normalisation, compatibilité, modularité

Normalisation

situer les apports de chaque norme
- C++11 / 14 / 17 — move, lambdas, structured bindings
- C++20 — concepts, ranges, modules, coroutines
- C++23 / 26 — std::expected, std::print, amorces
identifier les éléments retirés et dépréciés

Travaux pratiques :

Audit d’un code C++98 compilé en -std=c++20 -Wall

Compatibilité

détecter la disponibilité d’une fonctionnalité via feature test macros
- __cpp_concepts, __cpp_lib_ranges
- bascule conditionnelle selon le support
- tests portables de présence d’en-tête

Travaux pratiques :

Détection portable de la présence de <ranges> via feature test macros

Modularité

organiser un projet avec modules
- unités modulaires et interfaces
- import et export
- migration progressive depuis les headers
gérer les dépendances en CMake moderne — Conan, vcpkg

Travaux pratiques :

Conversion d’un couple header / source en module
Intégration dans un projet CMake avec dépendance fmt gérée par vcpkg

Jour 1 - Après-midi

Concepts, comparaisons, compile-time

Concepts

contraindre la généricité avec concepts et requires
- concepts standards — integral, regular, equality_comparable
- concepts custom définis sur des expressions
- lisibilité supérieure à enable_if

Travaux pratiques :

Remplacement d’un enable_if existant par un concept nommé

Comparaisons

simplifier la comparaison avec l’opérateur <=>
- génération automatique de <, <=, >, >=
- catégories fortes et partielles
- comparaisons mixtes avec types tiers

Travaux pratiques :

Classe Version avec opérateur <=>

Compile-time

étendre l’évaluation compile-time
- constinit pour initialisation garantie
- consteval pour fonctions forcées constantes
- constexpr étendu sur allocations et types
exploiter les lambdas améliorées — lambdas template, captures par initialisation

Travaux pratiques :

Fonction consteval calculant un hash à la compilation
Lambda générique récursive sans std::function

Jour 2 - Matin

Formatage et ranges

Formatage

formater du texte moderne avec std::format et std::print
personnaliser le format d’un type custom en spécialisant std::formatter

Travaux pratiques :

Spécialisation de std::formatter pour un type Evenement
Sortie formatée via std::print

Ranges

composer des traitements avec les ranges
- vues lazy
- pipes | pour chaînage
- algorithmes compatibles ranges
combiner plusieurs sources avec les vues avancées — zip, enumerate, chunk

Travaux pratiques :

Pipeline de traitement d’un flux de logs — filter | transform | take
Composition de vues avec zip pour corréler timestamp et message

Jour 2 - Après-midi

Types somme, dates, expected

Types somme

chaîner des traitements avec std::optional et ses opérations monadiques C++23
dispatcher sur plusieurs alternatives — std::variant, std::visit

Travaux pratiques :

Chaînage monadique des appels avec and_then et or_else
Dispatch sur un variant d’événements via std::visit

Dates

manipuler dates et fuseaux horaires
- calendrier — year_month_day
- durées typées — days, months, years
- fuseaux — time_zone, conversions

Travaux pratiques :

Planificateur multi-fuseaux affichant des échéances calculées

Expected

retourner résultat ou erreur sans exception avec std::expected
- valeur ou erreur typée
- chaînage monadique — and_then, transform, or_else

Travaux pratiques :

Refactor d’une API retournant des codes d’erreur vers expected<T, Erreur>

Jour 3 - Matin

Concurrence et parallélisme

Concurrence

écrire des coroutines
- co_await pour suspendre
- co_yield pour générer
- co_return pour terminer
gérer proprement l’arrêt d’un thread — std::jthread, std::stop_token
exploiter executors et std::async revisités

Travaux pratiques :

Générateur de Fibonacci écrit en coroutine
Worker jthread arrêtable proprement depuis l’extérieur
Pool de tâches retournant des future

Parallélisme

paralléliser la STL via les politiques d’exécution
- std::execution::seq — séquentiel
- std::execution::par — parallèle
- std::execution::par_unseq — parallèle vectorisé

Travaux pratiques :

std::sort parallèle comparé au séquentiel, mesures au chrono

Jour 3 - Après-midi

Migration legacy assistée

structurer une migration de base legacy par passes successives
- audit initial et métriques
- passes ciblées par thème
- validation continue entre passes
automatiser les modernisations avec clang-tidy — checks modernize-*
reconnaître les patterns courants de refactoring assisté
tirer parti d’un assistant IA sur du code C++
- apports sur RAII, smart pointers, concepts
- pièges sur templates et UB
valider la non-régression
- suite de tests
- sanitizers ASan, UBSan, TSan
- benchmarks avant / après

Travaux pratiques :

Module C++03 fourni migré en plusieurs passes
Passe 1 — clang-tidy modernize-* en automatique
Passe 2 — corrections manuelles RAII et smart pointers
Passe 3 — concepts et ranges assistés par un assistant IA
Validation complète par suite de tests et sanitizers

Travaux pratiques

Développement d’une application utilisant l’API open source Simbody écrite pour C20
Etudier la migration d’une application C++ en C++ moderne
Adapter les exemples de Design Pattern en utilisant des pointeurs managés
Transcodage avec lecture de fichier synchrone puis asynchrone

Modalités d’évaluation des acquis

En cours de formation, par des études de cas ou des travaux pratiques. En fin de formation, par un questionnaire d’auto-évaluation.

Voir aussi

Vous serez peut-être intéressés par les formations suivantes :

Formation DEV-CPP-200 — C++ - Avancé. Domaine : Développement. Niveau : Intermédiaire. Durée : 3 jours (21 heures). Mots-clés : c++, développement, avancé, c++20, c++23. Cylian Formation, Dijon.