Le C++ fascine par l'infini des réalisations et des manières de programmer qu'il permet. D'une part, il hérite du langage C qui lui procure une base pour tout ce qui concerne l'écriture algorithmique, et d'autre part il est doté de puissants outils de structuration orientés objet.

Ce livre s'adresse aux personnes qui débutent en programmation avec le langage C++ ou ayant déjà programmé dans d'autres langages. Il tient compte des dernières évolutions de C++ et éclaircit la complexité du langage par une exploration systématique de ses composantes natives (algorithmique fondamentale, programmation objet, généricité) auxquelles sont ajoutés quelques éléments sélectionnés parmi les bibliothèques standards (smart pointers ou pointeurs intelligents, conteneurs et contrôle d'erreur avec les exceptions).

La progression pédagogique de l’auteur se déroule en quatre temps.

L’auteur commence par traiter de notions qui concernent l'écriture algorithmique et ses fondamentaux : variables, opérations, structures de contrôle (if, switch, boucles, fonctions, attributs).
Dans un second temps, le lecteur bascule vers la programmation objet avec les structures et les classes puis il se concentre sur la généricité, les bibliothèques personnelles, les modules et les espaces de noms. Ensuite, l'étude des pointeurs, introduite avec les tableaux et les chaînes de caractères, est développée d'abord avec les pointeurs classiques puis avec les pointeurs-objets dits smart pointers. La quatrième et dernière étape vient compléter l'arsenal des outils natifs de la programmation objet avec les concepts d'héritage, de polymorphisme, de virtualité, de classes abstraites et d'interfaces. Pour finir, le livre s’achève sur la gestion des erreurs.

Tout au long du livre, l'auteur fournit des exemples de programmes apportant la mise en pratique nécessaire pour s'approprier le langage. Tous les programmes sont en téléchargement sur le site www.editions-eni.fr.

Téléchargements

• RI2LCPP

Introduction

1. 1. L'univers C++
2. 2. Cartographie pédagogique de la grammaire C++
3. 3. Organisation du livre
4. 4. Public visé
5. 5. Clés pour apprendre
6. 6. Documentations, versions, environnements

Premiers programmes

1. 1. C inclus en C++
2. 2. Premiers programmes
   1. 2.1 La fonction main() : entrée du programme
   2. 2.2 "Hello world !" en C
   3. 2.3 "Hello world !"en C++
3. 3. Bibliothèques, espaces de noms, instruction using
   1. 3.1 Bibliothèque , directive #include
   2. 3.2 Espace de noms et instruction using
   3. 3.3 L'espace de noms standard std
   4. 3.4 Inclusion de bibliothèques C en C++
4. 4. Activer C++20

Variables simples

1. 1. Introduction
2. 2. Hérité du C
   1. 2.1 Différents types de variables
   2. 2.2 Déclaration des variables
   3. 2.3 Affecter et afficher une valeur
   4. 2.4 Opérateur sizeof
   5. 2.5 Préfixes 0b, 0x, 0 et séparateur (')
   6. 2.6 Suffixes L, LL et f
   7. 2.7 Caractères, codage ASCII
   8. 2.8 Renommer des types avec typedef
3. 3. Apports du C++
   1. 3.1 Initialisations des variables
   2. 3.2 Type auto
   3. 3.3 Opérateur decltype
   4. 3.4 Opérateur typeid, bibliothèque

Constantes

1. 1. Constantes const et constexpr
   1. 1.1 Hérité du C
   2. 1.2 Apports du C++
      1. 1.2.1 Plus de rigueur sur const
      2. 1.2.2 Valeurs constantes définies à la compilation : mot-clé constexpr
2. 2. Énumérations : créations de types enum
   1. 2.1 Hérité du C
   2. 2.2 Apports C++
3. 3. Directive macroprocesseur #define

Affichage et saisie console

1. 1. Hérité du C
   1. 1.1 Affichage : fonction printf
      1. 1.1.1 Chaînes de caractères
      2. 1.1.2 Convertir des valeurs en caractères avec des formats
      3. 1.1.3 Paramétrer l'affichage de printf
   2. 1.2 Formatage : fonctions sprintf, snprintf, sprintf_s, snprintf_s
   3. 1.3 Saisie de valeurs : fonctions scanf, scanf_s
2. 2. Apports C++
   1. 2.1 Utiliser cout et cin
      1. 2.1.1 Écrire dans la console avec cout
      2. 2.1.2 Entrer des valeurs avec cin
      3. 2.1.3 Contrôle d'erreur simple
   2. 2.2 Instructions de formatage en sortie
      1. 2.2.1 Afficher des valeurs booléennes
      2. 2.2.2 Largeur minimum de l'affichage
      3. 2.2.3 Alignement des sorties
      4. 2.2.4 Choisir un caractère de remplissage
      5. 2.2.5 Afficher ou non les zéros après la virgule
      6. 2.2.6 Afficher le signe des nombres positifs

Opérations

1. 1. Hérité du C
   1. 1.1 Notion d'expression
   2. 1.2 Opérations arithmétiques
   3. 1.3 Valeurs aléatoires
      1. 1.3.1 Avoir des suites différentes
      2. 1.3.2 Définir une fourchette
   4. 1.4 Opérations bit à bit
      1. 1.4.1 ET : opérateur &
      2. 1.4.2 OU exclusif : opérateur ^
      3. 1.4.3 OU inclusif : opérateur |
      4. 1.4.4 Complément : opérateur ~
      5. 1.4.5 Décalages gauche et droite : opérateurs >> et <<
      6. 1.4.6 Priorités des opérateurs bit à bit
2. 2. Apports C++
   1. 2.1 Surcharger les opérateurs
   2. 2.2 La bibliothèque

Conversions de types

1. 1. Hérité du C
   1. 1.1 Le principe
   2. 1.2 Opérateur de conversion
   3. 1.3 Exemple : nombre aléatoire avec décimales
2. 2. Apports du C++
   1. 2.1 static_cast
   2. 2.2 const_cast
   3. 2.3 reinterpret_cast
   4. 2.4 dynamic_cast

Structures de contrôle

1. 1. Hérité du C
   1. 1.1 Bloc d'instructions
   2. 1.2 L'instruction conditionnelle if
   3. 1.3 Définir une condition
      1. 1.3.1 Opérateurs de comparaisons
      2. 1.3.2 L'opérateur unaire NON : !
   4. 1.4 Le couple d'instructions if-else
   5. 1.5 La forme contractée du if-else, opérateur conditionnel "?"
   6. 1.6 La cascade d'instructions if - else if - else
   7. 1.7 Les tests multiconditions (ET/OU)
      1. 1.7.1 Conjonction ET : opérateur &&
      2. 1.7.2 ET avec plus de deux expressions membres
      3. 1.7.3 Disjonction OU, opérateur ||
      4. 1.7.4 OU avec plus de deux expressions membres
      5. 1.7.5 ET prioritaire sur OU
   8. 1.8 Branchement : switch
   9. 1.9 Rupture de séquence : goto avec étiquette
   10. 1.10 Les trois boucles : while, do-while et for
       1. 1.10.1 Boucle TANT QUE : le while
       2. 1.10.2 Boucle FAIRE {...} TANT QUE : le do-while
       3. 1.10.3 Boucle comptée POUR : le for
       4. 1.10.4 Boucles imbriquées
   11. 1.11 Sortie et saut forcés dans une boucle
       1. 1.11.1 Sortir avec l'instruction break
       2. 1.11.2 Passer à l'itération suivante avec l'instruction continue
       3. 1.11.3 Sortir d'une ou de plusieurs boucles imbriquées avec l'instruction goto
2. 2. Apports du C++
   1. 2.1 Condition if ou else-if marquée constexpr
   2. 2.2 Boucle for (:) "pour chaque"

Fonctions

1. 1. Hérité du C
   1. 1.1 Principe
   2. 1.2 Fonction sans retour et sans paramètre
   3. 1.3 Déclaration et visibilité d'une fonction
   4. 1.4 Fonctions avec paramètres
      1. 1.4.1 Copie de valeurs et passage par valeur
      2. 1.4.2 Déplacer le curseur en écriture de la fenêtre console
      3. 1.4.3 Changer la couleur des caractères
      4. 1.4.4 À propos de la couleur en console
      5. 1.4.5 Afficher une lettre à une position et d'une couleur donnée dans la console
      6. 1.4.6 Tracer une ligne horizontale
      7. 1.4.7 Le programme complet
   5. 1.5 Fonctions avec retour
      1. 1.5.1 Retourner un nombre aléatoire entre 0 et 1
      2. 1.5.2 Retourner le résultat d'un jeté de deux dés à six faces
      3. 1.5.3 Programme complet
      4. 1.5.4 Types des valeurs de retour
   6. 1.6 Fonctions avec retour et avec paramètres
      1. 1.6.1 Conversion en chiffres romains
   7. 1.7 Fonction et qualificatif static
      1. 1.7.1 Qualificatif static et fonctions
   8. 1.8 Fonctions récursives
   9. 1.9 Nommer les fonctions
      1. 1.9.1 Contraintes syntaxiques
      2. 1.9.2 Sens des noms choisis
      3. 1.9.3 Normes et styles pour la mise en forme du code source
2. 2. Apports du C++
   1. 2.1 Fonctions embarquées "inline"
   2. 2.2 Fonctions constantes marquées constexpr
   3. 2.3 Fonctions marquées const
   4. 2.4 Fonctions déclarées noexcept
   5. 2.5 Valeurs par défaut de paramètres
   6. 2.6 Surcharge des fonctions
   7. 2.7 Références et passage par référence
   8. 2.8 Expression lambda (fonction anonyme)
      1. 2.8.1 Principe
      2. 2.8.2 Syntaxe générale
      3. 2.8.3 Les clauses de capture
      4. 2.8.4 Clauses de capture multiples
      5. 2.8.5 Spécification mutable
      6. 2.8.6 Listes de paramètres
      7. 2.8.7 Spécification d'une exception
      8. 2.8.8 Le type de retour
      9. 2.8.9 Lambda constexpr
      10. 2.8.10 Récupérer une lambda et appels possibles
      11. 2.8.11 Quelques précisions
   9. 2.9 Fonction operator et surcharge des opérateurs
   10. 2.10 Fonctions génériques (template, auto)

Précisions sur les variables, attributs

1. 1. Précisions sur les variables
   1. 1.1 Visibilité et durée de vie d'une variable
   2. 1.2 Masquage d'une variable
   3. 1.3 Variable static
2. 2. Attributs
   1. 2.1 Principe et syntaxe
   2. 2.2 Exemples d'utilisation
      1. 2.2.1 Expérimentation GNU
      2. 2.2.2 Expérimentation GSL Microsoft
   3. 2.3 Attributs standards
      1. 2.3.1 [[noreturn]] (depuis C++11)
      2. 2.3.2 [[fallthrough]] (depuis C++17)
      3. 2.3.3 [[deprecated]], [[deprecated("reason")]] (depuis C++14)
      4. 2.3.4 [[nodiscard]] (depuis C++17) [[nodiscard("reason")]] (depuis C++20)
      5. 2.3.5 [[maybe_unused]] (depuis C++17)
      6. 2.3.6 [[likely]] et [[unlikely]] (depuis C++20)
      7. 2.3.7 [[no_unique_address]] (depuis C++20)

Structures et classes

1. 1. Hérité du C
   1. 1.1 Principe de la structure
   2. 1.2 Disposer d'une structure
      1. 1.2.1 Définir un type de structure
      2. 1.2.2 Déclarer une variable structure
      3. 1.2.3 Initialiser à la déclaration
      4. 1.2.4 Accéder aux éléments avec l'opérateur point
      5. 1.2.5 Copier deux structures
   3. 1.3 Structures et fonctions
      1. 1.3.1 Fonction d'initialisation d'une entité
      2. 1.3.2 Fonctions d'affichage et d'effacement
      3. 1.3.3 Fonction pour avancer
      4. 1.3.4 Boucle événementielle
      5. 1.3.5 Contrôle du rythme de l'animation
      6. 1.3.6 Rendre invisible le curseur en écriture
      7. 1.3.7 Démo entité mobile
   4. 1.4 Structures imbriquées
2. 2. Apports du C++ : la structure devient une classe

Classes

1. 1. De la structure à la classe
   1. 1.1 Des droits d’accès : public, protected, private
   2. 1.2 Des fonctions membres
      1. 1.2.1 Cas général
      2. 1.2.2 Fonctions membres déclarées const
   3. 1.3 Une initialisation renforcée
      1. 1.3.1 Initialisations à la déclaration
      2. 1.3.2 Initialisations par défaut dans la classe
   4. 1.4 Des constructeurs et des initialiseurs
      1. 1.4.1 Initialiser avec des constructeurs
      2. 1.4.2 Constructeur par défaut
      3. 1.4.3 Initialisations contraintes par les constructeurs existants
      4. 1.4.4 Constructeurs avec initialiseurs
      5. 1.4.5 L'initialiseur initialise les constantes
   5. 1.5 Le pointeur this
   6. 1.6 Un programme C muté objet C++
      1. 1.6.1 Réécriture des entités mobiles
      2. 1.6.2 Amélioration du programme
   7. 1.7 Que dire des structures en C++ ?
      1. 1.7.1 Des aspects pratiques
      2. 1.7.2 Réfléchir l'interface des objets
2. 2. Accesseurs (property en anglais)
   1. 2.1 Lire une variable private ou protected
   2. 2.2 Modifier une variable private ou protected
   3. 2.3 Intérêt d'un appel de fonction
3. 3. Qualificatif static dans une classe
4. 4. default et delete pour les fonctions spéciales de classe
   1. 4.1 Fonctions spéciales
   2. 4.2 Utiliser default (rappel et précision)
   3. 4.3 Utiliser delete
5. 5. Surcharge des opérateurs
   1. 5.1 Principe
   2. 5.2 Fonction operator hors classe
      1. 5.2.1 Exemple addition : operator+
      2. 5.2.2 Exemple décalage à gauche : operator<<
   3. 5.3 Fonction operator dans une classe
      1. 5.3.1 operator+ sans retour
      2. 5.3.2 operator+ avec retour de l'objet courant (*this)
      3. 5.3.3 opérator+ avec retour d'un nouvel objet résultant
   4. 5.4 Transformer un objet en une fonction (objet fonction ou fonction objet)
   5. 5.5 Utiliser l'opérateur bool
6. 6. L’instruction friend ("ami")

Unions, unions illimitées

1. 1. Principe
2. 2. Union de structures
3. 3. Union discriminée
4. 4. Union illimitée (C++11)

Généricité, template, auto

1. 1. Principe du template
2. 2. Template de fonction
   1. 2.1 Définir une fonction générique
   2. 2.2 Fonction avec plusieurs types génériques
   3. 2.3 Évaluation des types génériques à la compilation
   4. 2.4 Expressions lambda et template
   5. 2.5 Template pour passer des valeurs
3. 3. Template de classe
   1. 3.1 Syntaxe
      1. 3.1.1 Syntaxe générale
      2. 3.1.2 Syntaxe des constructeurs
      3. 3.1.3 Syntaxe avec plusieurs types génériques
      4. 3.1.4 Déduction de type à l'initialisation
      5. 3.1.5 Types par défaut
      6. 3.1.6 L'instance du template influence le type de la classe
   2. 3.2 Paramétrages
      1. 3.2.1 Paramétrage avec des valeurs
      2. 3.2.2 Template en paramètre de template
      3. 3.2.3 Spécialiser une fonction pour un type donné
      4. 3.2.4 Spécialiser une classe complète
      5. 3.2.5 Spécialiser une classe avec plusieurs types génériques
      6. 3.2.6 Paramétrage avec des objets fonctions
4. 4. Template variadique et paquet de paramètres
   1. 4.1 Principe : l'opérateur variadique (...)
   2. 4.2 Template variadique de fonction
      1. 4.2.1 Cas général
      2. 4.2.2 Itérations simplifiées (fold expression, C++17)
      3. 4.2.3 Deux paramètres variadiques
   3. 4.3 Template variadique de classe
5. 5. Utilités standards à base de templates
   1. 5.1 La classe bitset
   2. 5.2 La classe tuple<...>
   3. 5.3 La classe pair<>
   4. 5.4 Alternatives à l'union
      1. 5.4.1 La classe variant
      2. 5.4.2 La classe optional
      3. 5.4.3 La classe any
   5. 5.5 La classe std::function<>
6. 6. Concepts (C++20)
   1. 6.1 Définir un concept
   2. 6.2 L'expression requires
      1. 6.2.1 Exemple d'utilisation sans paramètre
      2. 6.2.2 Exemple d'utilisation avec paramètres
   3. 6.3 Établir des contraintes
      1. 6.3.1 Conjonction ET (&&)
      2. 6.3.2 Disjonction OU (||)
7. 7. Spécification auto
   1. 7.1 Principes généraux
      1. 7.1.1 Variables simples auto
      2. 7.1.2 Listes auto
   2. 7.2 Templates et auto
      1. 7.2.1 Spécification decltype(auto)
      2. 7.2.2 Comparaison entre auto et template
      3. 7.2.3 Utilisation de auto dans un template

Bibliothèques, modules et espaces de noms

1. 1. Créer une bibliothèque classique (.h)
   1. 1.1 Contenu du fichier outils.h
   2. 1.2 Contenu du fichier outils.cpp
   3. 1.3 Contenu du fichier main.cpp
   4. 1.4 Problèmes de redéfinitions, instruction extern
2. 2. Espaces de noms (namespace)
   1. 2.1 Cartographier du code
   2. 2.2 Accéder au contenu
   3. 2.3 Répartition sur plusieurs fichiers
      1. 2.3.1 Espace de noms dans une bibliothèque
      2. 2.3.2 Espace de noms réparti entre plusieurs fichiers
      3. 2.3.3 Espace de noms ToutpourlesChiens réorganisé
   4. 2.4 Imbriquer des espaces de noms
   5. 2.5 Espaces de noms inline
   6. 2.6 Espace de noms anonymes
   7. 2.7 Remplacer un nom trop long par un alias
3. 3. La directive using
   1. 3.1 Faciliter l'accès à un espace de noms
   2. 3.2 Constituer un alias de type
4. 4. Modules (C++20)
   1. 4.1 Principe
   2. 4.2 Créer une unité d'interface de module (.ixx)
   3. 4.3 Définir le contenu du module
   4. 4.4 Importer le module dans un fichier source
   5. 4.5 Utiliser des bibliothèques standards dans un module
   6. 4.6 Utiliser une bibliothèque personnelle dans un module
   7. 4.7 Éléments non exportables dans un module
   8. 4.8 Partitionner un module
   9. 4.9 Espaces de noms dans un module
   10. 4.10 Créer un fichier d'implémentation de module
   11. 4.11 Création d'un module Outils (version 1)
   12. 4.12 Création d'un module Outils (version 2)
   13. 4.13 Modules ou bibliothèques ?
5. 5. Précision sur la liaison entre C++ et C

Tableaux statiques, introduction conteneurs

1. 1. Hérité du C
   1. 1.1 Principe du tableau
   2. 1.2 Disposer d'un tableau
      1. 1.2.1 Définir et déclarer un tableau
      2. 1.2.2 Des constantes pour les tailles
      3. 1.2.3 Accéder aux éléments du tableau avec l'opérateur [ ]
      4. 1.2.4 Débordement de tableau
      5. 1.2.5 Parcourir un tableau avec une boucle for
      6. 1.2.6 Initialiser un tableau à la déclaration
   3. 1.3 Tableaux à plusieurs dimensions
      1. 1.3.1 Matrice à deux dimensions
      2. 1.3.2 Tableaux à n dimensions
      3. 1.3.3 Initialiser à la déclaration
      4. 1.3.4 Parcourir un tableau à plusieurs dimensions
   4. 1.4 Tableaux en paramètre de fonctions
2. 2. Apports du C++
   1. 2.1 Boucle for (:) "pour chaque"
   2. 2.2 Récupérer une liste variadique d'éléments dans un tableau statique
   3. 2.3 Tableaux d'objets, exemple fourmilière (version 1)
   4. 2.4 Tableau dans une classe, fourmilière (version 2)
      1. 2.4.1 Paramétrer la classe
      2. 2.4.2 La classe fourmilière
   5. 2.5 Tableau dans une classe, exemple pile générique
      1. 2.5.1 Création de la pile
      2. 2.5.2 Tri paramétrable de la pile (objet fonction)
      3. 2.5.3 Spécialisation sur un type
3. 3. Introduction des conteneurs
   1. 3.1 La classe array
   2. 3.2 La classe vector
   3. 3.3 La classe list
   4. 3.4 Contenus variadiques
   5. 3.5 Boucle for_each de la bibliothèque

Chaînes de caractères, la classe string

1. 1. Hérité du C
2. 2. Apports du C++ : la classe string

Pointeurs

1. 1. Principes généraux
   1. 1.1 Adresse et mémoire
   2. 1.2 Une variable pointeur
   3. 1.3 Quatre opérateurs dédiés
   4. 1.4 Cinq utilisations classiques
2. 2. Hérité du C
   1. 2.1 Déclarer un pointeur dans un programme
   2. 2.2 Opérateur adresse : &
   3. 2.3 Opérateur étoile : *
   4. 2.4 Opérateur flèche : ->
   5. 2.5 Opérateur crochets : [ ]
   6. 2.6 Priorité des quatre opérateurs
   7. 2.7 Pointeurs et constantes
      1. 2.7.1 Pointeur variable sur un objet constant
      2. 2.7.2 Pointeur constant sur un objet variable
      3. 2.7.3 Pointeur constant sur un objet constant
   8. 2.8 Le pointeur générique void*
   9. 2.9 Pointeurs de fonction
      1. 2.9.1 Une fonction est une adresse
      2. 2.9.2 Reconnaître le type d’une fonction
      3. 2.9.3 Appeler une fonction via un pointeur du bon type
      4. 2.9.4 Cast nécessaire si le pointeur est un void*
      5. 2.9.5 Pourquoi des pointeurs de fonction ? Les « callbacks »
3. 3. Apports du C++
   1. 3.1 Un souci de rigueur
      1. 3.1.1 Plus de rigueur
   2. 3.2 Opérateurs new et delete, new[ ] et delete[ ]
      1. 3.2.1 Principe
      2. 3.2.2 Respecter les couples new-delete et new[]-delete[]
      3. 3.2.3 Allocation d'un tableau de 0 élément ?!
      4. 3.2.4 Précisions sur l'opérateur new
   3. 3.3 La valeur nullptr
   4. 3.4 Type référence & (pointeur constant et simplifié)
      1. 3.4.1 Principe
      2. 3.4.2 Une référence est constante
      3. 3.4.3 Référence déclarée const
      4. 3.4.4 Connaître la valeur de la référence
   5. 3.5 Retourner une référence
      1. 3.5.1 Piège à éviter
      2. 3.5.2 Masquer un tableau avec une fonction
   6. 3.6 Type référence && (Right value)
      1. 3.6.1 Des catégories d'expressions
      2. 3.6.2 lvalues (objets persistants) et rvalues (objets temporaires)
      3. 3.6.3 Affectations d'objets temporaires rvalues
      4. 3.6.4 Objets rvalues passés en paramètre de fonction
      5. 3.6.5 Remarque : une ambigüité possible
      6. 3.6.6 Déclarateur de référence rvalue : &&
      7. 3.6.7 Référence rvalue && en paramètre de fonction
      8. 3.6.8 Référence rvalue && en paramètre de constructeur
   7. 3.7 Conversions en rvalue
      1. 3.7.1 Un static_cast<>
      2. 3.7.2 La fonction de déplacement std::move
      3. 3.7.3 La fonction de transfert std::forward<>
      4. 3.7.4 Situation de conversion implicite de rvalue(&&) à lvalue (&)
      5. 3.7.5 Liste variadique et transfert parfait
   8. 3.8 Spécificateur decltype et références

Pointeurs et références dans la classe

1. 1. Introduction
2. 2. Le destructeur
   1. 2.1 Les éléments non dynamiques s'autodétruisent (rappel)
   2. 2.2 Problème des éléments dynamiques perdus en mémoire
   3. 2.3 Écrire un destructeur des éléments dynamiques
   4. 2.4 Appels explicites du destructeur
   5. 2.5 Destructeur appelé avec delete
3. 3. Constructeur de copie
   1. 3.1 Principe
   2. 3.2 Copier un objet à la déclaration
   3. 3.3 Copier des objets possédant des données dynamiques
      1. 3.3.1 Problème des données dynamiques
      2. 3.3.2 Interdire la copie
      3. 3.3.3 Implémenter un constructeur de copie
4. 4. Constructeur de déplacement
   1. 4.1 Principe
   2. 4.2 Possible avertissement noexcept
   3. 4.3 Constructeur de déplacement avec données dynamiques
5. 5. Surcharge des opérateurs et données dynamiques
   1. 5.1 Affectation de copie (operator=)
   2. 5.2 Affectation de déplacement (move)
   3. 5.3 Surcharge operator+
6. 6. Questions diverses
   1. 6.1 Spécialiser une classe générique en pointeur
   2. 6.2 Créer un singleton
   3. 6.3 Références dans une classe

Pointeurs-objets ou "smart pointers"

1. 1. Introduction
   1. 1.1 La bibliothèque memory
   2. 1.2 Transformer un pointeur en objet
2. 2. La classe std::unique_ptr
   1. 2.1 Expérimentation du pointeur unique
   2. 2.2 Survol du contenu principal
      1. 2.2.1 Constructeurs
      2. 2.2.2 Destructeur
      3. 2.2.3 Six surcharges d'opérateurs
      4. 2.2.4 Cinq fonctions membres
      5. 2.2.5 Quatre fonctions hors classe
3. 3. La classe std::shared_ptr
   1. 3.1 Expérimentation du pointeur partagé
   2. 3.2 Survol du contenu principal
      1. 3.2.1 Constructeurs
      2. 3.2.2 Destructeur
      3. 3.2.3 Six surcharges d'opérateurs
      4. 3.2.4 Cinq fonctions membres
      5. 3.2.5 Fonctions hors classe
      6. 3.2.6 Fonctions hors classe de conversion
4. 4. La classe std::weak_ptr
   1. 4.1 Expérimentation du pointeur "simple observateur"
   2. 4.2 Survol du contenu principal
      1. 4.2.1 Constructeurs
      2. 4.2.2 Destructeur
      3. 4.2.3 Six fonctions membres
      4. 4.2.4 Surcharge opérateur =
5. 5. Allocateur de mémoire : la classe std::allocator

Pointeurs, utilisations classiques

1. 1. Introduction
2. 2. Pointeur en paramètre (passage par référence)
   1. 2.1 Expérimentation avec pointeur classique
   2. 2.2 Simplification de l'écriture avec des références C++
   3. 2.3 Tableau en paramètre
      1. 2.3.1 Tableau à une dimension
      2. 2.3.2 Tableaux à plusieurs dimensions
3. 3. Allocation dynamique et tableaux
   1. 3.1 Tableau de pointeurs
   2. 3.2 Allocation d'un tableau à une dimension
   3. 3.3 Allocation d'un tableau à plusieurs dimensions
      1. 3.3.1 Allocation d'une matrice de int
      2. 3.3.2 Allocation d'une forme à six dimensions de points
   4. 3.4 Quelques pièges classiques de l'allocation dynamique
4. 4. Relier des objets
   1. 4.1 Associer deux types structures style C
      1. 4.1.1 Structures Avion et Pilote
      2. 4.1.2 Avion ou pilote existent-ils ?
      3. 4.1.3 Avion ou pilote sont-ils libres ?
      4. 4.1.4 Relier avion et pilote
      5. 4.1.5 Délier un avion et un pilote
      6. 4.1.6 Constructeurs Avion et Pilote
      7. 4.1.7 Afficher Avion et Pilote
      8. 4.1.8 Détruire un Avion ou un Pilote
      9. 4.1.9 Code complet, main action
   2. 4.2 Associer des classes de même type
   3. 4.3 Élaborer une liste, fourmilière (version 3)

Associations entre classes

1. 1. Introduction
2. 2. Principes des associations pour les relations entre objets
   1. 2.1 Association simple
   2. 2.2 Agrégation
   3. 2.3 Composition
   4. 2.4 Problème syntaxique en C++
3. 3. Associations simples : messages entre objets
   1. 3.1 Liaison non réciproque entre deux objets
   2. 3.2 Liaison réciproque entre deux objets
4. 4. Agrégations : coopération entre objets
   1. 4.1 Liaison à sens unique (exemple guitare, guitariste)
   2. 4.2 Partage d'objets pointés (plusieurs musiciens, une guitare)
      1. 4.2.1 Musiciens simultanés
      2. 4.2.2 Plusieurs musiciens successifs
5. 5. Liaisons réciproques entre objets
   1. 5.1 Problème de syntaxe
   2. 5.2 Déclaration de type incomplet
   3. 5.3 Limite du type incomplet
   4. 5.4 Résolution du problème
   5. 5.5 Exemple Terminator
6. 6. Composition : dépendance entre objets
   1. 6.1 Choisir entre agrégation ou composition
   2. 6.2 Techniques envisageables
   3. 6.3 Pointeur d'objet en propriété
   4. 6.4 Objet en propriété
   5. 6.5 Référence d'objet en propriété

Héritage

1. 1. Principe
2. 2. Définir une classe dérivée
3. 3. Appeler explicitement un constructeur de la classe de base
4. 4. Redéfinition de données ou de fonctions
5. 5. Spécifier un membre de la classe de base
6. 6. Droits d'accès locaux de la classe héritée
7. 7. Droits d'accès globaux de la classe héritée
8. 8. Héritage multiple
   1. 8.1 Principe et syntaxe
   2. 8.2 Exemple : InDominusRex
   3. 8.3 Relations transversales dans un arbre de classes
   4. 8.4 Héritage multiple avec une base virtuelle
9. 9. Comment identifier un héritage
   1. 9.1 Distinction entre héritage et association
   2. 9.2 Distinction entre attributs et nouvelle classe

Polymorphisme et virtualité

1. 1. Principe
2. 2. Accès pointeurs limité par son type
3. 3. Autorisation d'accès pour les fonctions virtuelles
4. 4. Destructeur virtuel
5. 5. Intérêt des fonctions virtuelles

Classe abstraite et interface

1. 1. Classe abstraite, fonctions virtuelles pures
2. 2. Tronc commun pour dériver
3. 3. Interface
4. 4. Récupérer une sous classe depuis une base abstraite
5. 5. Résumé classe abstraite et interface
6. 6. Expérimentation : exemples des super-héros, les Avengers
   1. 6.1 Classe de base super-héros, interface des fonctions d'action
      1. 6.1.1 Définition et stockage des armes
      2. 6.1.2 Définition et stockage du paramétrage émotionnel
      3. 6.1.3 Interface de fonctions pour tous les super-héros
      4. 6.1.4 Définition de la classe "SuperHeros"
   2. 6.2 Une dérivée pour chaque Avenger
      1. 6.2.1 Classe "CaptainAmerica"
      2. 6.2.2 Classes Hulk, IronMan, BlackWidow et Thor
   3. 6.3 Souhait du polymorphisme et impossibilité
   4. 6.4 Virtualité, intérêt de l'interface des fonctions d'action
   5. 6.5 Classe abstraite

Gestion des erreurs

1. 1. Introduction
2. 2. Socle hérité du C
   1. 2.1 Retourner un booléen
   2. 2.2 Retourner un numéro d'erreur
   3. 2.3 Afficher des informations au moment de l'erreur
   4. 2.4 Bibliothèques C de contrôle d'erreur
      1. 2.4.1 La bibliothèque (errno.h)
      2. 2.4.2 La bibliothèque (assert.h)
3. 3. Contrôle d'erreur C++
   1. 3.1 Introduction
      1. 3.1.1 Bibliothèques de diagnostics
      2. 3.1.2 Conseil sur les exceptions
   2. 3.2 Instructions natives throw, try et catch
      1. 3.2.1 Retour throw
      2. 3.2.2 Saut try et récupération catch
      3. 3.2.3 Retour throw d'un appel de fonction
      4. 3.2.4 Instruction throw sans valeur de retour
      5. 3.2.5 Bloc catch(...) par défaut
      6. 3.2.6 Exception non gérée
      7. 3.2.7 Fonctions déclarées noexcept
   3. 3.3 L'en-tête
      1. 3.3.1 Principe
      2. 3.3.2 Classe std::exception
      3. 3.3.3 Les fonctions std::terminate, std::set_terminate, std::get_terminate
      4. 3.3.4 Utiliser la virtualité de la classe std::exception
   4. 3.4 Déclaration static_assert
   5.  
   6.  
   7.  
   8.  
   9.  
   10.  
   11. Index