Téléchargement de Modern CPP Programming - Téléchargement du code source Modern CPP Programming

Modern CPP Programming

C/C++

v1.8.0

Télécharger

Programmation C++ moderne

C++03 / C++11 / C++14 / C++17 / C++20 / C++23 / C++26

Ce cours en libre accès s'adresse à ceux qui sont déjà familiarisés avec le C et la programmation orientée objet vers un niveau de compétence en programmation C++. Le cours couvre les bases de la programmation C++ et passe ensuite à la sémantique et aux concepts avancés du C++.

Principales caractéristiques :

Gratuit et fréquemment mis à jour
26 conférences, plus de 1 800 diapositives
Inclure les derniers concepts et fonctionnalités standard du langage
Enseignement pratique : descriptions courtes et structurées, non verbeuses, associées au code
Exemples de code minimaux pour afficher uniquement une fonctionnalité ou un problème spécifique sans digresser
Aspects complémentaires du langage : outils, conventions de codage, organisation de projet et optimisation du code
Basé sur l'expérience : de nombreux aspects, exemples et problèmes proviennent de cas réels rencontrés au cours de mon travail d'ingénieur logiciel

Si vous appréciez le cours ou si vous le trouvez utile , veuillez ajouter une étoile

CHAPITRES

#	TITRE	AXE PRINCIPAL
1	Présentation (html)	Histoire du C/C++, Domaines d'applications, Introduction au cours
2	Préparation (html)	Livres, Comment compiler, Bonjour tout le monde
3	Concepts de base I (html)	Système de types, types fondamentaux et opérateurs
4	Concepts de base II (html)	Types intégraux et à virgule flottante et leur arithmétique
5	Concepts de base III (html)	Entités, énumérateurs, structures, instructions de flux de contrôle
6	Concepts de base IV (html)	Tas, pile, pointeurs, références, propriétés Const, opérateurs de conversion
7	Concepts de base V (html)	Fonctions, expressions Lambda, directives de prétraitement
8	Programmation orientée objet I (html)	Hiérarchie de classe, constructeur, destructeur, mots-clés de classe
9	Programmation orientée objet II (html)	Polymorphisme, surcharge d'opérateurs
10	Modèles et méta-programmation I (html)	Modèle de fonction, traits de type, utilitaires de compilation
11	Modèles et méta-programmation II (html)	Modèle de classe, SFINAE
12	Unités de traduction I (html)	Lien et règle de définition unique
13	Unités de traduction II (html)	Gérer plusieurs unités et fichiers de traduction, `#include` , Modules
14	Conventions de code I (html)	Organisation du projet, introduction aux conventions de code, conventions d'entités
15	Conventions du Code II (html)	Modèle, espace de noms, C++ moderne, maintenabilité, conventions de dénomination et de formatage
16	Débogage et tests (html)	Débogage d'exécution/mémoire, Sanitizers, Techniques de Harding, Test unitaire, Développement piloté par les tests
17	Écosystème (html)	Cmake, documentation et autres outils
18	Utilitaires (html)	Principales bibliothèques `std`
19	Conteneurs, itérateurs et algorithmes (html)	Conteneurs, itérateurs, algorithmes, plages
20	Sujets avancés I (html)	Sémantique de déplacement, référence universelle, déduction de type
21	Sujets avancés II (html)	Gestion des erreurs, idiomes C++, pointeurs intelligents
22	Optimisations des performances I (html)	Loi d'Ahmdal, Limites de performances, Concepts d'architecture (ILP, SIMD, etc.), Hiérarchie mémoire
23	Optimisations des performances II (html)	Optimisations arithmétiques, optimisations de mémoire, etc.
24	Optimisations des performances III (html)	Optimisations du compilateur, profilage, outils de benchmarking
25	Conception de logiciels I (html)	Concepts de base, principes, cas d'utilisation
26	Conception de logiciels II (html)	Modèles de conception et expressions idiomatiques

LIVRE TOUT-EN-UN : modern-cpp.pdf (peut-être quelques commits derrière), html

SUJETS EN DÉTAILS

1. Introduction

Un peu d'histoire des langages de programmation C/C++
Domaines d'application et de popularité
Philosophie C++
Faiblesse C++ : Alternatives C++, Pourquoi passer à un nouveau langage est-il difficile ?
Le cours

2. Préparation

Livres et références
Légende des diapositives
Quel éditeur/IDE/compilateur dois-je utiliser ?
Comment compiler ?
Hello World : Flux d'E/S

3. Concepts de base I - Système de types, types fondamentaux et opérateurs

Le système de types C++ : catégories de types, propriétés de types
Présentation des types fondamentaux C++ : types arithmétiques, suffixe et préfixe, types arithmétiques non standard, type void , nullptr
Règles de conversion
mot-clé auto
Opérateurs C++ : priorité des opérateurs, sémantique d'incrémentation/décrémentation de préfixe/postfix, opérateurs d'affectation, composés et virgule, opérateur de vaisseau spatial <=> , opérateurs de comparaison sécurisés

4. Concepts de base II - Types intégraux et à virgule flottante

Types de données intégrales : entiers à largeur fixe, size_t , ptrdiff_t , uintptr_t , sémantique des opérations arithmétiques, promotion, troncature, comportement non défini, arithmétique de saturation
Types à virgule flottante et arithmétique : Norme à virgule flottante IEEE et autres représentations, Valeurs normales/dénormalisées, Infini, Pas un nombre ( NaN ), Machine Epsilon, Unités à la dernière place (ULP), Aide-mémoire, Limites et fonctions utiles, Arithmétique propriétés, comportement des valeurs spéciales, comportement non défini, détecter les erreurs à virgule flottante
Problèmes à virgule flottante : annulation catastrophique, comparaison à virgule flottante

5. Concepts de base III - Entités et flux de contrôle

Entités
Déclaration et définition
Recenseurs
struct , Bitfield, union
Flux de contrôle : instruction if , boucles for et while , base de plage for boucle, switch , goto , éviter l'avertissement de variable inutilisée
Espace de noms : espace de noms global explicite, alias d'espace de noms, using -declaration, using namespace -directive, espace de noms inline
Attributs : [[nodiscard]] , [[maybe_unused]] , [[deprecated]] , [[noreturn]]

6. Concepts de base IV - Concepts de mémoire

Pointeurs : opérations de pointeur, opérateur d'adresse de & , accès aux membres struct , pointeur void , conversion de pointeur, arithmétique de pointeur, pointeurs sauvages et suspendus
Tas et pile : pile de mémoire, new , delete , allocation de placement sans allocation, allocation sans lancement, fuite de mémoire
Initialisation : initialisation de variable, initialisation uniforme, initialisation de tableau, initialisation de structure, liaison de structure, initialisation de mémoire dynamique
Références
Const et expressions constantes : Contants et littéraux, const , constexpr , consteval , constinit , if constexpr , std::is constant evaluated() , if consteval
mot clé volatile
Conversion de type explicite : static_cast , const_cast , reinterpret_cast , jeu de mots de type, std::bit_cast , conversion d'initialisation uniforme, gls::narrow_cast
Opérateur sizeof : présentation, [[no_unique_address]]

7. Concepts de base V - Fonctions et prétraitement

Fonctions : Passage par valeur, Passage par pointeur, Passage par référence, Signature de fonction et surcharge, Surcharge et =delete , Paramètres par défaut
Pointeur de fonction et objets de fonction
Expressions Lambda : liste de capture, expression Lambda et relation de fonction, notes sur les paramètres, composabilité, récursion, constexpr/consteval , template , mutable , [[nodiscard]] , liste et classes de capture
Prétraitement : Préprocesseurs, Erreurs courantes, Macros d'emplacement source, Macros de compilation conditionnelle, Opérateur de chaîne ( # ), #error et #warning , #pragma , Opérateur de collage de jetons ## , Macro variadique

8. Programmation orientée objet I - Concepts de classe

Classes C++ : idiome RAII
Hiérarchie des classes
Spécificateurs d'accès : Spécificateurs d'accès à l'héritage, Quand utiliser public/protected/private pour les données membres ?
Constructeur de classe : constructeur par défaut, initialisation de classe, initialisation uniforme pour les objets, constructeur délégué, mot-clé explicit , [[nodiscard]] et classes
Copier le constructeur
Destructeur de classe
Constructeurs, destructeurs et opérateurs par défaut ( = default )
Mots clés de classe : this , static , const , mutable , using , friend , delete

9. Programmation orientée objet II - Polymorphisme et surcharge d'opérateurs

Polymorphisme : Mécanismes C++ pour le polymorphisme, méthodes virtual , Table virtuelle, mot-clé override , mot-clé final , Erreurs courantes, Méthode virtuelle pure, Classe abstraite et interface
Castage d’héritage et identification du type d’exécution
Surcharge d'opérateur : Présentation, Opérateur de comparaison < , Opérateur de vaisseau spatial <=> , Opérateur d'indice [] , Opérateur d'indice multidimensionnel [] , Opérateur d'appel de fonction () , Opérateur statique [] et opérateur () , Opérateur de conversion T() , Surcharge de type de retour résolution, Opérateurs d'incrémentation et de décrémentation ++ / -- , Opérateur d'affectation = , Opérateur de flux << , Notes sur l'opérateur
Disposition des objets C++ : agrégat, classe triviale, classe de mise en page standard, données anciennes simples (POD), hiérarchie

10. Modèles et métaprogrammation I – Modèles de fonctions et utilitaires de compilation

Modèle de fonction : Présentation, Instanciation du modèle, Paramètres du modèle, Paramètre du modèle - valeur par défaut, Surcharge, Spécialisation
Variable de modèle
Types de paramètres de modèle : notes de type générique, espace réservé auto , type de paramètre de modèle de classe, types de tableau et de pointeur, type de fonction
Utilitaires de compilation : static_assert , using le mot-clé, le mot-clé decltype
Traits de type : présentation, bibliothèque de traits de type, manipulation de types

11. Modèles et méta-programmation II - Modèles de classe et SFINAE

Modèle de classe : spécialisation de classe, constructeur de modèle de classe
Déduction automatique du modèle de constructeur (CTAD)
Modèle de classe - Concepts avancés : Classe + Fonction - spécialisation, Noms dépendants - typename et mots-clés template , Hiérarchie et using du modèle de classe, Mot-clé friend , Arguments du modèle de modèle
Méta-programmation de modèles
SFINAE : l'échec de la substitution n'est pas une erreur : fonction SFINAE, classe SFINAE
Modèle variadique : expression pliante, modèle de classe variadique
Concepts C++20 : Présentation, mot-clé concept , clause requires , expression requires , expression requires + clause, clause requires + expression, requires et constexpr , requires imbriqué
Débogage de modèles

12. Unités de traduction I - Lien et règle de définition unique

Concepts de base : Unité de traduction, Portée locale et globale, Liens
Classe et durée de stockage : durée de stockage, classe de stockage, mot-clé static , espace de noms anonyme, mots-clés extern
Liaison de const et constexpr : fiasco de l'ordre d'initialisation statique
Résumé des liens
Gérer plusieurs unités de traduction : Classe en plusieurs unités de traduction
One Definition Rule (ODR) : Problèmes de variables globales, ODR - Point 3, fonctions/variables inline , constexpr et inline
ODR - Modèle de fonction : Cas, mot-clé extern
ODR - Modèle de classe : Requêtes, mot-clé extern
Comportement et résumé non définis de l'ODR

13. Unités de traduction II - Inclure, module et espace de noms

#include Problèmes : Inclure la garde, la déclaration Forward, les dépendances circulaires, les erreurs de liaison courantes
Modules C++20 : Présentation, Terminologie, Visibilité et accessibilité, Types d'unités de module, Mots clés, Fragment de module global, Fragment de module privé, Unité de module d'en-tête, Partitions de module
Compilation de plusieurs unités de traduction : indicateurs fondamentaux du compilateur, méthodes de compilation
Bibliothèques en C++ : Bibliothèque statique, Construire des bibliothèques statiques, Utiliser des bibliothèques statiques, Bibliothèque dynamique, Construire des bibliothèques dynamiques, Utiliser des bibliothèques dynamiques, Interface binaire d'application (ABI), Démangling, Rechercher des dépendances de bibliothèques dynamiques, Analyser des symboles objet/exécutable

14. Conventions du code I

Organisation de projet C++ : Répertoires de projets, Fichiers de projet, Notes d'organisation de projet "Commune", Alternative - Organisation de projet "Canonique"
Styles et conventions de codage : présentation, styles de codage populaires
Fichiers d'en-tête et #include : garde #include , syntaxe #include , ordre de #include , conventions courantes de nom de fichier d'en-tête/source
Prétraitement : Macro, Instructions de prétraitement
Variables : variables globales static , conversions
Recenseurs
Types arithmétiques : types intégraux signés ou non signés, conversion de types intégraux, types intégraux : taille et autres problèmes, types à virgule flottante
Fonctions : paramètres de fonction, arguments de fonction, valeurs de retour de fonction, spécificateurs de fonction, expressions lambda
Structures et classes : struct vs class , initialisation, listes d'initialiseurs accolades, fonctions membres spéciales, =default , =delete , autres problèmes, héritage, style

15. Conventions du Code II

auto
Modèles et déduction de type
Flux de contrôle : flux de contrôle redondant, if/else , comparaison, switch , for/while
Espace de noms : using namespace , espace de noms anonyme/sans nom, conception d'espace de noms et de classe, style
Fonctionnalités C++ modernes : mots clés, fonctionnalités, classe, bibliothèque
Maintenabilité : Compréhension du code, Fonctions, Template et Débuction, Bibliothèque
Portabilité
Nommage : entités, variables, fonctions, conventions de style, application des styles de nommage
Lisibilité et formatage : Espacement horizontal, Pointeurs/Références, Espacement vertical, Accolades, Décorateurs de caractères, Réduire la verbosité du code, Autres problèmes
Documentation du code : documentation des fonctions, syntaxe des commentaires, documentation des fichiers

16. Débogage et tests

Présentation du débogage
Affirmations
Débogage d'exécution : Points d'arrêt, Points de surveillance / Points de capture, Flux de contrôle, Pile et informations, Imprimer, Désassembler, std::breakpoint
Débogage mémoire : valgrind
Techniques de renforcement : utilisation de la pile, vérifications de bibliothèque standard, protections de comportement non définies, protections de flux de contrôle
Désinfectants : Désinfectant d'adresses, Désinfectant de fuites, Désinfectants de mémoire, Désinfectant de comportement non défini, Désinfectant de données d'échantillonnage
Résumé du débogage
Avertissements du compilateur
Analyse statique
Tests de code : tests unitaires, développement piloté par les tests (TDD), couverture de code, tests Fuzz
Qualité du code : clang-tidy

17. Écosystème - Cmake et autres outils

CMake : cmake et ctest
Documentation du code : doxygen
Statistiques de code : Comptage des lignes de code, Analyseur de complexité cyclomatique
Autres outils : formatage du code - clang-format , Compiler Explorer , transformation du code - CppInsights , complétion de code alimentée par l'IA - recherche de code local - ugrep , ripgrep , hypergrep , moteur de recherche de code - searchcode/grep.app , analyse comparative du code - Quick-Bench , Police pour le codage

18. Utilitaires

Flux d'E/S : Manipulateur, ofstream/ifstream
Chaînes : std::string , Conversion de/vers valeurs numériques, std::string_view , std::format , std::print
Vue : std::span
Bibliothèques mathématiques
Nombre aléatoire : Concepts de base, C++ <random> , Seed, Période et qualité PRNG, Distribution, Algorithmes récents et performances, Quasi-aléatoire
Mesure du temps : heure de l'horloge murale, heure de l'utilisateur, heure du système
Modèles de classe Std : std::pair , std::tuple , std::variant , std::optional , std::any , std::stacktrace
Bibliothèque du système de fichiers : méthodes de requête, méthodes de modification

19. Conteneurs, itérateurs et algorithmes

Conteneurs et itérateurs
Conteneurs de séquence : std::array , std::vector , std::deque , std::list , std::forward_list
Conteneurs associatifs : std::set , std::map , std::multiset
Adaptateurs de conteneur : std::stack , std::queue , std::priority_queue
Implémenter un itérateur personnalisé : implémenter un itérateur simple
Notes de l'itérateur :
Méthodes utilitaires de l'itérateur : std::advance , std::next , std::prev , std::distance , méthodes d'accès au conteneur, traits de l'itérateur
Bibliothèque d'algorithmes : std::find_if , std::sort , std::accumulate , std::generate , std::remove_if
Plages C++20 : Concepts clés, Vue plage, Adaptateur de plage, Fabrique de plage, Algorithmes de plage, Actions de plage

20. Sujets avancés I

Move Semantic : références lvalues et rvalues , sémantique de déplacement, std::move , sémantique de déclaration de classe
Référence universelle et renvoi parfait : référence universelle, règles de regroupement des références, renvoi parfait
Catégories de valeur
& , && Qualificatifs de référence et surcharge volatile
Copier Elision et RVO
Type Déduction : Passage par référence, Passage par pointeur, Passage par valeur, déduction auto , auto(x) : Decay-copy
const Exactitude

21. Sujets avancés II

Comportement non défini : comportement illégal, comportement spécifique à la plate-forme, comportement non spécifié, détection d'un comportement non défini
Gestion des erreurs : gestion des erreurs récupérables, code de retour, exceptions C++, définition d'exceptions personnalisées, mot-clé noexcept , problèmes d'allocation de mémoire, code de retour et résumé des exceptions, std::expected , approches alternatives de gestion des erreurs
Pointeurs intelligents : std::unique_ptr , std::shared_ptr , std::weak_ptr
Concurrence : méthodes Thread, Mutex, Atomic, parallélisme basé sur les tâches

22. Optimisation I - Concepts de base

Introduction : Loi de Moore, Limites de la loi de Moore, Raisons d'optimisation
Concepts de base : complexité asymptotique, compromis temps-mémoire, cycle de développement, loi d'Ahmdal, débit, bande passante, latence, limites de performances, intensité arithmétique
Concepts d'architecture de base : débit d'instructions (IPC), exécution dans l'ordre et dans le désordre, pipeline d'instructions, parallélisme au niveau des instructions (ILP), loi de Little, parallélisme au niveau des données (DLP) et instructions vectorielles (SIMD), Parallélisme au niveau des threads (TLP), Single Instruction Multiple Threads (SIMT), RISC, jeux d'instructions CISC
Hiérarchie de la mémoire : concepts de hiérarchie de la mémoire, localité de la mémoire, latence cœur à cœur et affinité des threads, modèle d'ordonnancement de la mémoire

23. Optimisation II - Optimisation du code

Opérations d'E/S : printf , E/S mappées en mémoire, accélère le chargement des données brutes
Optimisations de la mémoire : mémoire tas, mémoire pile, utilisation du cache, alignement des données, prélecture de la mémoire
Types arithmétiques : types de données, opérations arithmétiques, conversion, virgule flottante, fonctions intrinsèques du compilateur, valeur dans une plage, table de recherche
Flux de contrôle : branches, conseils de branche - [[likely]] / [[unlikely]] , entiers signés/non signés, boucles, levage de boucle, déroulement de boucle, assertions, conseils du compilateur [[assume]]/std::unreacheable() , Récursivité
Fonctions : coût d'appel de fonction, passage d'arguments, inlining de fonction, attributs de fonction, alias de pointeurs
Programmation orientée objet
Bibliothèque Std et autres aspects linguistiques

24. Optimisation III - Optimisations sans codage et analyse comparative

Optimisations du compilateur : À propos du compilateur, Indicateurs d'optimisation du compilateur, Indicateurs d'optimisation à virgule flottante, Indicateurs d'optimisation de l'éditeur de liens, Indicateurs d'architecture, Aide le compilateur à produire un meilleur code, Optimisation guidée par profil (PGO), Optimiseur binaire de post-traitement, Optimisations polyédriques
Techniques de transformation du compilateur : transformations de base, décommutation de boucle, fusion de boucle, fission de boucle, échange de boucle, pavage de boucle
Bibliothèques et structures de données
Analyse comparative des performances : que tester ?, Qualité de la charge de travail/de l'ensemble de données, comportement du cache, performances stables du processeur, considérations multithreads, disposition de la mémoire du programme, surcharge de mesure, optimisations du compilateur, évaluation des métriques
Profilage : gprof , uftrace , callgrind , cachegrind , perf Linux profileur
Informatique parallèle : concurrence vs parallélisme, mise à l'échelle des performances, loi de Gustafson, langages de programmation parallèle

25. Conception de logiciels I - Concepts de base (PROJET)

Livres et références
Concepts de base : Abstraction, interface et module, Invariant de classe
Principes de conception de logiciels : Séparation des préoccupations, Faible couplage, cohésion élevée, Encapsulation et masquage d'informations, Conception par contrat, Décomposition du problème, Réutilisation du code
Complexité logicielle : Entropie logicielle, Dette technique
Les principes de conception SOLID
Conception de classe : principe de l'interface de classe, fonctions membres et fonctions libres, fonctions d'espace de noms et méthodes statiques de classe
Étude de cas BLAS GEMM
Posséder des objets et des vues
Valeur vs sémantique de référence
Variables globales

26. Software Design II - Modèles de conception et idiomes (PROJET)

Expressions idiomatiques C++ : règle de zéro, règle de trois, règle de cinq
Design Pattern : Singleton, Pointeur vers l'implémentation (PIMPL), Modèle de modèle curieusement récurrent (CRTP), Fonctions virtuelles de modèle