Cours de langage C++

Leçon 1 • Entrée, sortie et débogage de base

Présente std::cin et std::cout pour les entrées-sorties console et le débogage de base avec des instructions d'affichage et les diagnostics du compilateur. Développe des habitudes pour un développement itératif.

Leçon 2 • Pipeline de compilation et d'édition de liens

Explique le prétraitement, la compilation, l'assemblage et l'édition de liens comme des étapes distinctes. Les apprenants tracent comment les fichiers source deviennent des exécutables binaires.

Leçon 3 • Configuration de l'environnement de développement

Installe et configure les compilateurs, les éditeurs et les outils de build sur les principales plateformes. Garantit que chaque apprenant dispose d'un espace de travail reproductible avant d'écrire du code.

Leçon 4 • Structure d'un programme C++

Dissèque l'anatomie d'un fichier source C++ minimal, y compris les en-têtes, la fonction main et les espaces de noms. Relie les règles de syntaxe au modèle de compilation.

Leçon 1 • Opérateurs arithmétiques et binaires

Explore les opérateurs arithmétiques, modulo, d'incrémentation et binaires avec les règles de précédence. Les apprenants appliquent des opérateurs pour résoudre des problèmes numériques et de manipulation de bits.

Leçon 2 • Déclaration et initialisation de variables

Distingue les formes d'initialisation par défaut, par valeur, par copie et directe. Met l'accent sur l'initialisation uniforme avec accolades pour éviter les conversions restrictives.

Leçon 3 • Expressions, instructions et comportement indéfini

Définit les points de séquence, les catégories de valeurs et les sources courantes de comportement indéfini. Développe des habitudes de codage disciplinées dès le départ.

Leçon 4 • Conversions de type et transtypage

Explique la promotion implicite, la restriction et les transtypages C++ explicites. Les apprenants apprennent à convertir des types en toute sécurité sans comportement indéfini.

Leçon 1 • Récursivité et considérations sur la pile

Applique la récursivité à des problèmes classiques et analyse la profondeur de la pile et les modèles de récursion terminale. Les apprenants équilibrent l'élégance avec les limitations pratiques de la pile.

Leçon 2 • Instructions conditionnelles

Couvre les chaînes if-else, switch-case et l'opérateur ternaire avec les règles de traversée. Les apprenants sélectionnent la construction appropriée pour chaque scénario de décision.

Leçon 3 • Boucles et itération

Présente les boucles for, while, do-while et for basée sur une plage avec break et continue. Les apprenants choisissent les boucles en fonction du modèle d'itération et de la condition de terminaison.

Leçon 4 • Surcharge de fonctions et name mangling

Explique comment le compilateur résout les appels de fonction surchargés et génère des noms déformés. Les apprenants écrivent des surcharges non ambiguës et maintenables.

Leçon 1 • Pointeurs intelligents et propriété

Présente unique_ptr, shared_ptr et weak_ptr comme des wrappers RAII qui automatisent la gestion de la mémoire. Les apprenants remplacent les pointeurs propriétaires bruts par des alternatives sûres.

Leçon 2 • Références et leur sémantique

Distingue les références lvalue des pointeurs et introduit les références rvalue pour la sémantique de déplacement. Les apprenants utilisent les références pour écrire du code efficace et sûr pour les alias.

Leçon 3 • Erreurs de mémoire courantes et sanitizers

Identifie les pointeurs pendants, les dépassements de tampon, les use-after-free et les erreurs de double suppression. Les apprenants utilisent AddressSanitizer et Valgrind pour détecter et corriger les bugs.

Leçon 4 • Pointeurs et arithmétique d'adresses

Introduit la déclaration de pointeur, le déréférencement, les pointeurs nuls et l'arithmétique de pointeurs. Relie l'adressage bas niveau au parcours de tableaux et à la performance.

Leçon 1 • Polymorphisme et fonctions virtuelles

Explique la répartition virtuelle, les vtables, les fonctions virtuelles pures et les classes abstraites. Les apprenants écrivent du code extensible qui suit le principe ouvert-fermé.

Leçon 2 • Classes, structures et encapsulation

Définit la syntaxe des classes et des structures, les spécificateurs d'accès et les fonctions membres. Les apprenants encapsulent les données pour appliquer des invariants et cacher les détails d'implémentation.

Leçon 3 • Constructeurs, destructeurs et la règle des cinq

Couvre les constructeurs par défaut, paramétrés, par copie et par déplacement ainsi que les destructeurs. Les apprenants appliquent la règle des cinq pour gérer correctement les ressources.

Leçon 4 • Surcharge d'opérateurs

Surcharge les opérateurs arithmétiques, de comparaison, de flux et d'indice pour les types définis par l'utilisateur. Les apprenants suivent les conventions qui rendent les opérateurs surchargés intuitifs.

Leçon 1 • Modèles de classe

Définit des modèles de classe avec des fonctions membres, une spécialisation partielle et des paramètres par défaut. Les apprenants construisent des conteneurs génériques basés sur des modèles de la bibliothèque standard.

Leçon 2 • Notions de base de la métaprogrammation de modèles

Utilise les traits de type, if constexpr et le calcul à la compilation pour spécialiser le comportement. Les apprenants optimisent les chemins de code sans surcharge à l'exécution.

Leçon 3 • Modèles variadiques et packs de paramètres

Développe les packs de paramètres avec les expressions fold pour gérer un nombre arbitraire d'arguments. Les apprenants implémentent des wrappers de transfert et des utilitaires variadiques type-safe.

Leçon 4 • Modèles de fonction

Introduit la syntaxe des modèles de fonction, la déduction de type et l'instanciation explicite. Les apprenants remplacent les fonctions dupliquées spécifiques à un type par une seule version générique.

Leçon 1 • Utilitaires : Optional, Variant et Span

Utilise std::optional, std::variant, std::any et std::span pour exprimer des types nullable, somme et vue. Les apprenants éliminent les bugs de pointeur nul et les unions dangereuses.

Leçon 2 • Algorithmes standard

Applique les algorithmes de tri, recherche, transformation et partitionnement depuis <algorithm>. Les apprenants remplacent les boucles écrites à la main par des appels de bibliothèque expressifs et testés.

Leçon 3 • Chaînes, vues de chaînes et formatage

Couvre les opérations std::string, std::string_view pour un accès non propriétaire et std::format pour une sortie type-safe. Les apprenants traitent le texte efficacement sans copies inutiles.

Leçon 4 • Itérateurs et plages

Explique les catégories d'itérateurs, les algorithmes basés sur les plages et les plages et vues C++20. Les apprenants composent des pipelines paresseux qui traitent les données sans copies intermédiaires.

Leçon 1 • Sémantique de déplacement et catégories de valeurs

Approfondit la compréhension des références rvalue, de std::move et des types déplaçables uniquement. Les apprenants éliminent les copies inutiles dans les chemins de code critiques pour la performance.

Leçon 2 • Lambdas et modèles fonctionnels

Définit la syntaxe lambda, les modes de capture, les lambdas génériques et std::function. Les apprenants composent des fonctions d'ordre supérieur et des rappels avec un minimum de code passe-partout.

Leçon 3 • Stratégies de gestion des erreurs

Compare les exceptions, les codes d'erreur, std::expected et les assertions pour communiquer les échecs. Les apprenants choisissent des stratégies qui équilibrent sécurité, performance et clarté.

Leçon 4 • Profilage, optimisation et comportement indéfini

Profile avec perf et gprof, applique les optimisations du compilateur et élimine le comportement indéfini à l'aide de sanitizers. Les apprenants ajustent le code en fonction des données mesurées.