C++ - Initiation

Le C++ est le langage de choix pour les applications exigeantes en performance : jeux vidéo, systèmes embarqués, finance, simulation scientifique. Cette formation de 5 jours couvre le C++ moderne de bout en bout : fondamentaux, programmation objet avec RAII et smart pointers, sémantique de déplacement, héritage et polymorphisme, généricité avec templates et concepts, STL approfondie avec ranges, concurrence, outillage CMake et tests, et apports de l’IA dans le développement C++.

Public visé

Développeurs.

Prérequis

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

• Initiation à la programmation
• La conception orientée objet

Objectifs pédagogiques

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

• Programmer en C++ moderne en appliquant RAII et smart pointers
• Maîtriser l’héritage, le polymorphisme et la sémantique de déplacement
• Écrire du code générique avec templates et concepts
• Exploiter la STL et les ranges C++20
• Gérer la concurrence avec std::thread, std::async et std::atomic
• Mettre en place un projet CMake avec tests et sanitizers
• Tirer parti de l’IA comme assistant de développement C++

Programme

Jour 1 - Matin

Syntaxe, structure, fonctions

Syntaxe

• maîtriser la syntaxe de base
  • types et littéraux
  • opérateurs et expressions
  • portée et visibilité
  • structures de contrôle
• exploiter la syntaxe moderne
  • auto et decltype pour la déduction de types
  • nullptr en remplacement de NULL
  • range-based for pour parcourir un conteneur

Travaux pratiques :

• Programme calculant la moyenne d’un vector<double> avec déduction auto et parcours range-based

Structure

• structurer un programme multi-fichiers
  • préprocesseur et directives d’inclusion
  • séparation header / implémentation
  • compilation séparée et édition de liens
• organiser le code avec namespaces et alias de types

Travaux pratiques :

• Bibliothèque stats répartie en header et implémentation sous namespace dédié
• Alias de types pour clarifier les signatures publiques

Fonctions

• écrire des fonctions idiomatiques
  • passage par valeur, référence, référence const
  • surcharge par type de paramètres
  • qualificateur const sur les méthodes

Travaux pratiques :

• Fonctions moyenne et ecartType surchargées pour plusieurs types numériques
• Passage par référence const pour éviter les copies inutiles

Jour 1 - Après-midi

Compile-time et fondations objet

Compile-time

• évaluer à la compilation
  • constexpr pour constantes et fonctions
  • inline pour éviter les doublons d’édition de liens
  • calculs statiques sur types composites

Travaux pratiques :

• Constantes constexpr de frais bancaires utilisées dans une classe métier

Fondations objet

• concevoir des classes encapsulées
• construire des objets
  • constructeurs et liste d’initialisation
  • membres statiques et d’instance
  • destructeurs et ordre de destruction
• maîtriser la durée de vie — stack vs heap

Travaux pratiques :

• Classe Compte bancaire avec constructeurs multiples et initialisation par liste
• Destructeur traçant pour observer les ordres de vie
• Compteur statique d’instances actives

Jour 2 - Matin

RAII et smart pointers

RAII

• appliquer RAII comme principe de gestion des ressources
  • acquisition dans le constructeur
  • libération dans le destructeur
  • sûreté face aux exceptions

Travaux pratiques :

• Wrapper RAII autour d’un FILE* C garantissant la fermeture

Smart pointers

• utiliser les smart pointers
  • unique_ptr pour la propriété exclusive
  • shared_ptr pour la propriété partagée
  • weak_ptr pour casser les cycles de références
• situer new et delete comme API bas niveau à éviter
• détecter fuites et accès invalides avec les sanitizers — AddressSanitizer, LeakSanitizer

Travaux pratiques :

• Arbre binaire avec enfants en unique_ptr
• Démo de fuite mémoire sur code new / delete détectée par AddressSanitizer puis corrigée

Jour 2 - Après-midi

Copie, déplacement, RVO

Copie

• implémenter la sémantique de copie
  • constructeur de copie
  • opérateur d’affectation par copie
  • gestion des ressources possédées
• appliquer la rule of 3

Travaux pratiques :

• Classe Buffer respectant la rule of 3 avec gestion manuelle d’un tableau dynamique

Déplacement

• exploiter le déplacement
  • rvalue references
  • std::move comme cast vers rvalue
  • transfert de propriété sans copie
• étendre à la rule of 5 pour les types déplaçables

Travaux pratiques :

• Ajout du move constructor et du move assignment à Buffer
• Mesure d’impact du déplacement sur un vector<Buffer>

RVO

• tirer parti de copy elision et RVO pour éviter les copies

Travaux pratiques :

• Comptage d’appels de constructeurs avec et sans -fno-elide-constructors

Jour 3 - Matin

Héritage et polymorphisme

Héritage

• concevoir une hiérarchie par héritage public
  • ordre de construction et destruction
  • constructeurs de base explicites
  • héritage privé et protégé en cas particulier
• arbitrer entre composition et héritage

Travaux pratiques :

• Hiérarchie Forme → Cercle, Rectangle, Triangle
• Refactor d’une relation Voiture extends Moteur en composition

Polymorphisme

• exploiter le polymorphisme dynamique
  • fonctions virtuelles
  • override pour sécuriser les redéfinitions
  • final pour figer une hiérarchie
• définir des interfaces avec classes abstraites et fonctions virtuelles pures

Travaux pratiques :

• aire virtuelle pure sur Forme et destructeur virtuel
• Polymorphisme via pointeur sur base

Jour 3 - Après-midi

Généricité

• écrire du code générique avec templates
  • templates de fonctions
  • templates de classes
  • paramètres de type et non-type
• spécialiser un template pour un type précis
• contraindre la généricité avec les concepts C++20

Travaux pratiques :

• Fonctions génériques minVal, maxVal, clamp
• Pile générique Stack<T> avec spécialisation Stack<bool> pour compactage
• Contrainte de Stack<T> aux types copiables via un concept

Jour 4 - Matin

Conteneurs, chaînes, itérateurs

Conteneurs

• choisir le bon conteneur STL
  • séquentiels — vector, array, deque
  • associatifs ordonnés — map, set
  • associatifs non ordonnés — unordered_map, unordered_set
• regrouper des valeurs composites — std::pair, std::tuple

Travaux pratiques :

• Annuaire téléphonique stocké en unordered_map<string, string>
• Fonction de recherche retournant un tuple<bool, string, string>

Chaînes

• manipuler des chaînes et des vues — std::string, std::string_view

Travaux pratiques :

• Tokenizer basé sur string_view sans allocations

Itérateurs

• parcourir les données avec les itérateurs
  • catégories d’itérateurs
  • invalidation lors de modifications
  • begin / end et compatibilité algorithmes

Travaux pratiques :

• Parcours d’un conteneur via différentes catégories d’itérateurs

Jour 4 - Après-midi

Algorithmes, lambdas, ranges

Algorithmes

• exploiter les algorithmes standards
  • tri et recherche — sort, find, binary_search
  • transformations — transform, accumulate, copy_if
  • composition via prédicats

Travaux pratiques :

• Pipeline de traitement de notes — lecture fichier, filtrage, tri
• Calcul de moyenne via accumulate

Lambdas

• écrire des lambdas idiomatiques
  • captures par valeur, référence, liste explicite
  • mutable pour modifier les captures
• passer un traitement en paramètre avec std::function

Travaux pratiques :

• Filtrage des notes par lambda paramétré
• std::function pour basculer entre plusieurs prédicats

Ranges

• composer des transformations avec les ranges C++20 — vues et pipes

Travaux pratiques :

• Réécriture complète du pipeline de notes en ranges avec pipes

Jour 5 - Matin

Opérateurs, exceptions, types somme

Opérateurs

• surcharger les opérateurs de façon ciblée et lisible
  • opérateurs arithmétiques et de comparaison
  • opérateurs de flux << et >>
  • opérateurs d’affectation composés

Travaux pratiques :

• Classe Vecteur3D avec opérateurs +, ==, <<

Exceptions

• gérer les erreurs par exceptions typées
  • hiérarchie d’exceptions métier
  • propagation et capture
  • noexcept sur les chemins sûrs

Travaux pratiques :

• Parseur INI levant des exceptions typées

Types somme

• modéliser présence ou choix par type
  • std::optional pour valeur optionnelle
  • std::variant pour alternatives finies
• déstructurer des valeurs composites avec les structured bindings

Travaux pratiques :

• API find_user retournant optional<User>
• Consommation de l’API en structured bindings

Jour 5 - Après-midi

Concurrence, écosystème, IA

Concurrence

• comprendre le modèle mémoire C++
  • ordres de synchronisation — acquire, release, seq_cst
  • visibilité inter-threads
  • data races et comportement indéfini
• créer et coordonner des threads — cycle de vie, join vs detach
• paralléliser des traitements via std::async et std::future
• protéger les données partagées
  • std::mutex et verrous RAII
  • std::atomic pour opérations simples
  • patterns lock-free

Travaux pratiques :

• Utilitaire parallèle scannant un dossier avec partitionnement du travail

Écosystème

• mesurer durées et horodatages avec <chrono>
• manipuler le système de fichiers de manière portable avec <filesystem>
• formater du texte type-safe avec std::format
• outiller un projet moderne
  • CMake cibles et propriétés
  • Catch2 pour les tests unitaires
  • sanitizers — ASan, UBSan, TSan

Travaux pratiques :

• Rapport horodaté via <chrono> et formaté via std::format
• Intégration dans un projet CMake avec suite Catch2 et build sanitizers

IA

• identifier les apports concrets de l’IA sur un projet C++
  • complétion contextuelle
  • génération et modernisation de code
  • aide à la compréhension d’API
• distinguer les usages productifs
  • refactoring et migration
  • exploration d’API méconnue
  • rédaction de tests
• repérer les limites
  • hallucinations sur APIs obsolètes
  • code non idiomatique
  • vérification manuelle obligatoire

Travaux pratiques :

• Modernisation d’un fichier legacy C++03 vers C++20 guidée par un assistant IA

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.

Pour aller plus loin

Cette formation donne accès aux formations suivantes :

• C++ - Avancé
• C++ - Librairie Qt - Initiation

Voir aussi

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

• C++ - Avancé
• C++ - Librairie Qt - Initiation
• C++ - Librairie Qt - Perfectionnement

Formation DEV-CPP-100 — C++ - Initiation. Domaine : Développement. Niveau : Initiation. Durée : 5 jours (35 heures). Mots-clés : c++, développement, initiation, poo, stl. Cylian Formation, Dijon.