Programmation en C++ - Les fondamentaux
Maîtrisez les bases du C++ tout en intégrant les innovations du C++ moderne dès le départ, pour des applications robustes et maintenables qui respectent les standards industriels actuels.
Durée
5 jours
40 heures
Niveau
Débutant à intermédiaire
Modalité
Présentiel / Distanciel
Référence
CPP01
Présentation
Formation d'initiation au C++ moderne destinée aux développeurs possédant déjà une expérience en programmation orientée objet. Les participants découvrent progressivement les fondamentaux du langage, la programmation orientée objet, la gestion mémoire, la STL et les bonnes pratiques modernes.
Public concerné
- Développeurs souhaitant acquérir des bases solides du C++ moderne.
- Développeurs Java, C#, Python souhaitant migrer vers C++.
Prérequis
- Expérience en programmation orientée objet dans un autre langage.
- Aucune connaissance préalable du C++ nécessaire.
Objectifs de la formation
- Maîtriser la syntaxe et les idiomes du C++ moderne (C++11 à C++17).
- Mettre en œuvre les concepts POO.
- Comprendre la gestion mémoire C++.
- Exploiter efficacement la STL.
- Écrire du code robuste avec exceptions et outils modernes.
- Appliquer les bonnes pratiques du C++ moderne.
Programme détaillé
- Historique et évolution du C++
- Outils de développement
- Premier programme : structure de main()
- Variables et types fondamentaux
- Initialisation uniforme {}
- const et constexpr
- Pointeurs, références et tableaux
- Opérateurs et conversions
- Espaces de nommage
- auto et entrées/sorties
Travaux pratiques
- Prise en main de l'environnement de développement.
- Programmation d'un premier programme C++.
- Manipulation des types, conversions et espaces de noms.
- if, switch
- for, while, do while
- range-based for C++11
- Fonctions
- Passage par valeur et référence
- Valeurs par défaut
- Surcharge de fonctions
Travaux pratiques
- Fonctions de calcul.
- Moyenne, factorielle, Fibonacci.
- Manipulation références versus copies.
- Principes de la programmation orientée objet
- Définition d'une classe : attributs et méthodes
- Contrôle d'accès : private, protected, public
- Constructeurs et liste d'initialisation
- Délégation de constructeurs
- Destructeur et cycle de vie des objets
- Méthodes const
- Champs et méthodes statiques
- Méthodes et classes friend : quand et pourquoi
- Bonnes pratiques : explicit, responsabilité unique, invariants de classe
Travaux pratiques
- Implémentation de classes avec encapsulation stricte.
- Implémentation de constructeurs avec délégation.
- Méthodes const et statiques : cas d'usage concrets.
- Différence entre la pile et le tas : durée de vie, performance et fragmentation.
- Allocation dynamique : new, delete, new[] et delete[].
- Problématiques liées à la gestion mémoire : fuites mémoire, dangling pointers, double free.
- Constructeur de copie : sémantique de copie profonde.
- Constructeur de déplacement : sémantique de transfert.
- Règle des 3/5 : gestion complète du cycle de vie des objets.
Travaux pratiques
- Implémentation d'une classe TableauDynamique avec allocation manuelle complète.
- Gestion du constructeur, destructeur, constructeur de copie et constructeur de déplacement.
- RAII : principe fondamental de la gestion automatique des ressources.
- Smart pointers : std::unique_ptr, std::shared_ptr et std::weak_ptr.
- Création d'objets avec std::make_unique (C++14) et std::make_shared.
- Règle du zéro : conception de classes sans gestion mémoire manuelle.
Travaux pratiques
- Refactorisation de la classe TableauDynamique avec std::unique_ptr et std::vector.
- Résolution d'un cycle de références avec std::shared_ptr et std::weak_ptr.
- Principe de la dérivation.
- Définition des classes dérivées et gestion des constructeurs.
- Contrôle d'accès lors de l'héritage.
- Mise en œuvre du polymorphisme avec les fonctions virtuelles.
- Réutilisation du code : classes abstraites et interfaces.
- Aspects sémantiques et méthodologiques : factorisation du code.
Travaux pratiques
- Implémentation d'une hiérarchie de classes avec polymorphisme.
- Utilisation des mots-clés override et final pour sécuriser l'héritage.
- Création d'une classe abstraite avec méthodes virtuelles pures.
- Principe de la surcharge des opérateurs en C++.
- Surcharge interne et externe des opérateurs.
- Surcharge des opérateurs binaires.
- Surcharge particulière : opérateur indice ([]), opérateur fonction () et opérateur de conversion.
Travaux pratiques
- Surcharge des opérateurs + et ==.
- Implémentation de l'opérateur [] pour un accès sécurisé aux éléments d'un tableau.
- Modèle de classe : principes et mécanismes généraux.
- Création de classes génériques avec les templates.
- Spécialisation et surcharge de méthodes des modèles.
- Modèle de fonction : création de fonctions génériques.
- Spécialisation des modèles.
Travaux pratiques
- Création de classes et fonctions génériques utilisant les modèles.
- Mise en œuvre de spécialisations pour un type particulier.
- Présentation de la Standard Template Library (STL).
- Conteneurs séquentiels : std::vector, std::array, std::list.
- Conteneurs associatifs : std::map, std::unordered_map.
- Les itérateurs.
- Les algorithmes génériques.
- Parcours des collections avec range-based for.
Travaux pratiques
- Manipulation de std::vector : ajout, suppression et tri.
- Utilisation de std::map pour réaliser un annuaire téléphonique.
- Utilisation des algorithmes STL : find_if, sort et transform personnalisé.
- Mécanisme des exceptions en C++.
- Blocs try et catch.
- Génération d'exceptions avec throw.
- Conception d'une hiérarchie d'exceptions.
- std::optional (C++17) pour représenter des résultats potentiellement absents.
- noexcept et garanties d'exceptions : basique, forte et nothrow.
Travaux pratiques
- Mise en œuvre d'une gestion complète des exceptions.
- Création d'une hiérarchie d'exceptions personnalisée.
- Utilisation de std::optional pour éviter les valeurs nulles.