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 des diagnostics du compilateur. Développe des habitudes pour le 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 en tant qu'étapes distinctes. Les étudiants retracent 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 construction sur les principales plateformes. S'assure que chaque étudiant 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 principale 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 étudiants appliquent des opérateurs pour résoudre des problèmes numériques et de manipulation de bits.

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

Fait la distinction entre les formes d'initialisation par défaut, par valeur, par copie et directe. Met l'accent sur l'initialisation uniforme par accolades pour empêcher les conversions rétrécissantes.

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, le rétrécissement et les conversions explicites en C++. Les étudiants 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 motifs d'appel terminal. Les étudiants é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 cascade. Les étudiants 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 étudiants choisissent les boucles en fonction du motif 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 fonctions surchargées et génère des noms manglés. Les étudiants écrivent des surcharges qui sont sans ambiguïté et maintenables.

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

Présente unique_ptr, shared_ptr et weak_ptr comme des encapsulateurs RAII qui automatisent la gestion de la mémoire. Les étudiants remplacent les pointeurs de propriété 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 étudiants utilisent des références pour écrire du code efficace et sans alias.

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

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

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

Introduit la déclaration de pointeur, le déréférencement, les pointeurs nuls et l'arithmétique de pointeur. Relie l'adressage de bas niveau à la traversée de tableaux et aux performances.

Leçon 1 • Polymorphisme et fonctions virtuelles

Explique la répartition virtuelle, les vtables, les fonctions virtuelles pures et les classes abstraites. Les étudiants é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 étudiants encapsulent les données pour appliquer des invariants et masquer 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, de copie et de déplacement ainsi que les destructeurs. Les étudiants 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 étudiants suivent des 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 étudiants construisent des conteneurs génériques modelés sur les motifs de la bibliothèque standard.

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

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

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

Développe les paquets de paramètres avec des expressions de repli pour gérer un nombre arbitraire d'arguments. Les étudiants implémentent des encapsuleurs de transfert et des utilitaires variadiques sécurisés.

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 étudiants remplacent les fonctions spécifiques à un type dupliquées 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 les types nullables, somme et vue. Les étudiants éliminent les bogues de pointeur nul et les unions non sécurisées.

Leçon 2 • Algorithmes standard

Applique les algorithmes de tri, de recherche, de transformation et de partitionnement de <algorithm>. Les étudiants 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 sécurisée. Les étudiants manipulent 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 étudiants 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 étudiants éliminent les copies inutiles dans les chemins de code critiques pour les performances.

Leçon 2 • Lambdas et motifs fonctionnels

Définit la syntaxe lambda, les modes de capture, les lambdas génériques et std::function. Les étudiants 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 étudiants 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 étudiants ajustent le code en fonction des données mesurées.