Langage C++

L’héritage du C et la programmation orientée objet

Le C++ fascine par l’infini des réalisations et des manières de programmer

Héritage du C et programmation orientée objet

Frédéric DROUILLON est enseignant,
qu’il permet. D’une part il hérite du langage C qui lui procure une base chercheur et aussi créateur dans le
pour tout ce qui concerne l’écriture algorithmique, et d’autre part il est domaine de l’informatique et des arts
doté de puissants outils de structuration orientés objet. numériques. Il envisage la programma-
tion et ses langages comme un moyen
Ce livre sur le langage C++ s’adresse aux personnes qui débutent avec
d’expression et de formulation d’idées,
C++ et ayant déjà programmé dans d’autres langages.
une véritable écriture, qui nécessite de la
Le livre se divise en deux parties. Dans la première, l’auteur traite de recherche et de la créativité. L’objectif de
notions qui concernent l’écriture algorithmique et ses fondamentaux : son enseignement en langage C++ est
variables, opérations, structures de contrôle (if, switch, boucles, fonc- de permettre au lecteur d’acquérir un

Langage C++
Langage C++
tions), ensembles de variables (structures et tableaux), pointeurs... En savoir-faire fondamental en programma-
bref, il s’agit du langage C intégré au langage C++. L’auteur expose les tion informatique pour ensuite circuler le
correctifs et les élargissements fonctionnels apportés par le C++. Les plus librement possible dans les diffé-
classes et les objets commencent à apparaître avec la notion de struc- rentes techniques et langages de pro-
tures. Les améliorations apportées par le C++ sont mises en pratique dans grammation.
la réalisation de programmes au fur et à mesure de leur introduction.
Dans une deuxième partie se trouve ce qui fait la force du C++ : l’auteur
présente ainsi des outils de structuration qui permettent au lecteur de Les chapitres du livre

L’héritage du C
s’orienter franchement vers la programmation et l’architecture objet des
programmes. Il y détaille les notions de classes (constructeurs, destruc- Partie C++ hérité du C : Introduction • Pre-
miers programmes  • Variables simples,
teurs), d’objets, la problématique de relations entre objets, l’héritage, la
constantes, affectation • Affichage et saisie
problématique du polymorphisme avec virtualité, les notions de classe

abstraite et d’interface… L’ensemble des fonctionnalités associées à ces
différents concepts sont étudiées.
Pour finir, un chapitre compare le C et le C++. Certains outils comme les
et la programmation
console  • Opérations  • Conversions de
types • Structures de contrôle • Fonctions •
Portée et durée de vie des variables • Struc-
tures • Bibliothèques et espaces de noms •

pointeurs et les paramètres de fonctions peuvent en effet s’interpréter
différemment dans des situations créées par l’un ou l’autre des deux lan-
gages. Ce chapitre permet ainsi au lecteur de pallier la difficulté de passer
d’un langage à l’autre en prenant en compte ces différences d’interpréta-
tion.
Tout au long du livre, l’auteur fournit une série d’exercices diversifiés et
des exemples de programmes apportant la mise en pratique nécessaire
Téléchargement
pour s’approprier
www.editions-eni.fr
.fr le langage. Les éléments nécessaires à la réalisation des
exercices sont en téléchargement sur le site www.editions-eni.fr.
orientée objet
Unions  • Tableaux statiques  • Chaînes de
caractères • Pointeurs • Principales utilisa-
tions des pointeurs • Gestion des erreurs •
Deux automates cellulaires  • Partie La di-
mension objet du C++ : Classes, objets  •
Surcharge des opérateurs  • Classes et
membres static  • Classes génériques  •
Classe d’objets changeants  • Associations
(avec programmes d’illustration
et exercices)
entre objets • Héritage • Polymorphisme et
virtualité  • Classe abstraite et interface  •
Quelques comparaisons entre C et C++
ISBN : 978-2-409-01530-4

sur www.editions-eni.fr : Pour plus

d’informations :
b Le code source des programmes d’illustration.
29,90 €

Frédéric DROUILLON
Table des matières 1

Les éléments à télécharger sont disponibles à l'adresse suivante : 

http://www.editions-eni.fr 
Saisissez la référence ENI de l'ouvrage RILCPP dans la zone de recherche 
et validez. Cliquez sur le titre du livre puis sur le bouton de téléchargement.

Partie 1 : C++ hérité du C

Introduction
1. Le C++ au pied de la lettre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2. Cartographie de la grammaire C++ . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3. Organisation du livre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4. Modalités de comparaison C/C++ . . . . . . . . . . . . . . . . . . . . . . . . . . 29
5. Public visé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
6. Clés pour apprendre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
7. Environnements de développement . . . . . . . . . . . . . . . . . . . . . . . . . . 33

Chapitre 1
Premiers programmes
1. C inclus en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2. La fonction main() : entrée du programme. . . . . . . . . . . . . . . . . . . . . 36
3. "Hello world !" en C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4. "Hello world !"en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.1 Bibliothèque <iostream>, directive #include . . . . . . . . . . . . . . 39
4.2 L'instruction using namespace std; . . . . . . . . . . . . . . . . . . . . . . . 40
4.3 Inclusion des bibliothèques C en C++. . . . . . . . . . . . . . . . . . . . 41
2 Langage C++
L'héritage du C et la programmation orientée objet

Chapitre 2
Variables simples, constantes, affectation
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
2. Socle C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
2.1 Différents types de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
2.2 Déclaration des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
2.3 Affecter et afficher une valeur (avec cout qui est C++) . . . . . . 46
2.4 Caractères, codage ASCII . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
2.5 Variables constantes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
2.6 Énumérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
2.7 Directive #define . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
2.8 Opérateur Sizeof. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3. Apports C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.1 Déclarations plus souples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.2 Type bool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.3 Type long long ou unsigned long long . . . . . . . . . . . . . . . . . . . . 54
3.4 Type caractère unicode : wchar_t . . . . . . . . . . . . . . . . . . . . . . . . 55
3.5 Type auto (C++ 2011) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.6 Constantes (const) et énumération (enum)
plutôt que #define . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

Chapitre 3
Affichage et saisie console
1. Socle C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
1.1 Fonction printf (déconseillé en C++) . . . . . . . . . . . . . . . . . . . . 59
1.2 Fonctions sprintf et snprintf . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
1.3 Fonction scanf (déconseillé en C++) . . . . . . . . . . . . . . . . . . . . . 63
Table des matières 3

2. Apports C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
2.1 Utiliser cout et cin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
2.2 Instructions de formatage en sortie. . . . . . . . . . . . . . . . . . . . . . . 66
2.2.1 Largeur minimum de l'affichage . . . . . . . . . . . . . . . . . . . . 66
2.2.2 Alignement des sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
2.2.3 Choisir un caractère de remplissage . . . . . . . . . . . . . . . . . 67
2.2.4 Afficher ou non les zéros après la virgule. . . . . . . . . . . . . 68
2.2.5 Afficher le signe des nombres positifs . . . . . . . . . . . . . . . 69

Chapitre 4
Opérations
1. Socle C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
1.1 Notion d'expression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
1.2 Opérations arithmétiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
1.3 Valeurs aléatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
1.3.1 Avoir des suites différentes . . . . . . . . . . . . . . . . . . . . . . . . 74
1.3.2 Définir une fourchette. . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
1.4 Opérations bit à bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
1.4.1 ET : opérateur & . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
1.4.2 OU exclusif : opérateur ^ . . . . . . . . . . . . . . . . . . . . . . . . 77
1.4.3 OU inclusif : opérateur |. . . . . . . . . . . . . . . . . . . . . . . . . . 77
1.4.4 Complément : opérateur ~. . . . . . . . . . . . . . . . . . . . . . . . 78
1.4.5 Décalages gauche et droite : opérateurs >> et << . . . . 78
1.4.6 Priorités des opérateurs bit à bit . . . . . . . . . . . . . . . . . . . . 78
2. Apports C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
2.1 Surcharger les opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
4 Langage C++
L'héritage du C et la programmation orientée objet

Chapitre 5
Conversions de types
1. Socle hérité du C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
1.1 Le principe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
1.2 Opérateur de conversion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
1.3 Exemple : nombre aléatoire avec décimales . . . . . . . . . . . . . . . . 83
2. Apports du C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
2.1 static_cast<type> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
2.2 const_cast<type> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
2.3 reinterpret_cast<type>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
2.4 dynamic_cast<type> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

Chapitre 6
Structures de contrôle
1. Socle hérité du C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
1.1 Bloc d'instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
1.2 L'instruction conditionnelle if . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
1.3 Définir une condition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
1.3.1 Opérateurs de comparaisons. . . . . . . . . . . . . . . . . . . . . . . 92
1.3.2 L'opérateur unaire NON : ! . . . . . . . . . . . . . . . . . . . . . . . . 93
1.4 Le couple d'instructions if-else. . . . . . . . . . . . . . . . . . . . . . . . . . . 93
1.5 La forme contractée du if-else, opérateur conditionnel "?" . . . . 95
1.6 La cascade d'instructions if - else if - else . . . . . . . . . . . . . . . . . . 96
1.7 Les tests multiconditions (ET/OU). . . . . . . . . . . . . . . . . . . . . . . 97
1.7.1 Conjonction ET : opérateur &&. . . . . . . . . . . . . . . . . . . . 97
1.7.2 ET avec plus de deux expressions membres. . . . . . . . . . . 98
1.7.3 Disjonction OU, opérateur || . . . . . . . . . . . . . . . . . . . . . 99
1.7.4 OU avec plus de deux expressions membres . . . . . . . . . 100
1.7.5 ET prioritaire sur OU . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
1.8 Branchement : switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
1.9 Rupture de séquence : goto avec étiquette . . . . . . . . . . . . . . . . 104
Table des matières 5

1.10 Les trois boucles : while, do-while et for. . . . . . . . . . . . . . . . . . 105

1.10.1 Boucle TANT QUE : le while . . . . . . . . . . . . . . . . . . . . . 105
1.10.2 Boucle FAIRE {...} TANT QUE : le do-while . . . . . . . . 107
1.10.3 Boucle comptée POUR : le for . . . . . . . . . . . . . . . . . . . . 107
1.10.4 Boucles imbriquées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
1.11 Sortie et saut forcés dans une boucle . . . . . . . . . . . . . . . . . . . . 111
1.11.1 Sortir avec l'instruction break. . . . . . . . . . . . . . . . . . . . . 111
1.11.2 Passer à l'itération suivante
avec l'instruction continue . . . . . . . . . . . . . . . . . . . . . . . 112
1.11.3 Sortir d'une ou de plusieurs boucles imbriquées
avec l'instruction goto . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
2. Apports du C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
2.1 Boucle for (:) "pour chaque" . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

Chapitre 7
Fonctions
1. Socle hérité du C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
1.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
1.2 Exemple de fonction sans retour et sans paramètre. . . . . . . . . 116
1.3 Déclaration et visibilité d'une fonction . . . . . . . . . . . . . . . . . . . 118
1.4 Exemples de fonction avec paramètres . . . . . . . . . . . . . . . . . . . 120
1.4.1 Déplacer le curseur en écriture de la fenêtre console. . . 120
1.4.2 Changer la couleur des caractères. . . . . . . . . . . . . . . . . . 121
1.4.3 À propos de la couleur en console. . . . . . . . . . . . . . . . . . 122
1.4.4 Afficher une lettre à une position
et d'une couleur donnée dans la console . . . . . . . . . . . . 123
1.4.5 Tracer une ligne horizontale . . . . . . . . . . . . . . . . . . . . . . 123
1.4.6 Le programme complet . . . . . . . . . . . . . . . . . . . . . . . . . . 124
1.5 Exemples de fonction avec retour . . . . . . . . . . . . . . . . . . . . . . . 126
1.5.1 Retourner un nombre aléatoire entre 0 et 1. . . . . . . . . . 126
1.5.2 Retourner le résultat d'un jeté de deux dés à six faces . 126
1.5.3 Programme complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
6 Langage C++
L'héritage du C et la programmation orientée objet

1.6 Exemple de fonction avec retour et avec paramètres . . . . . . . . 128

1.6.1 Conversion chiffres romains . . . . . . . . . . . . . . . . . . . . . 128
2. Apports du C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
2.1 Fonctions embarquées "inline". . . . . . . . . . . . . . . . . . . . . . . . . . 131
2.2 Valeurs par défaut de paramètres . . . . . . . . . . . . . . . . . . . . . . . 132
2.3 Surcharge des fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
2.4 Fonctions génériques (template) . . . . . . . . . . . . . . . . . . . . . . . . 135

Chapitre 8
Portée et durée de vie des variables
1. Règles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
2. Masquage d'une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
3. Variables static . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

Chapitre 9
Structures
1. Socle hérité du C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
1.1 Principe de la structure. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
1.2 Disposer d'une structure / entite 1 . . . . . . . . . . . . . . . . . . . . . . 146
1.2.1 Définir un type de structure . . . . . . . . . . . . . . . . . . . . . . 146
1.2.2 Déclarer une variable structure. . . . . . . . . . . . . . . . . . . . 146
1.2.3 Initialiser à la déclaration . . . . . . . . . . . . . . . . . . . . . . . . 147
1.2.4 Accéder aux éléments avec l'opérateur point. . . . . . . . . 147
1.3 Utiliser un typedef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
1.4 Structures en retour ou en paramètre de fonction . . . . . . . . . . 153
1.4.1 Fonction d'initialisation d'une entite . . . . . . . . . . . . . . . 153
1.4.2 Fonctions d'affichage et d'effacement . . . . . . . . . . . . . . 154
1.4.3 Fonction pour avancer. . . . . . . . . . . . . . . . . . . . . . . . . . . 154
1.4.4 Boucle événementielle . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
1.4.5 Contrôle du rythme de l'animation . . . . . . . . . . . . . . . . 156
1.4.6 Rendre invisible le curseur en écriture . . . . . . . . . . . . . . 157
Table des matières 7

1.4.7 Programme complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

1.5 Structures imbriquées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
2. Apports du C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
2.1 typedef inutile pour les structures. . . . . . . . . . . . . . . . . . . . . . . 163
2.2 Fonctions comme champs de structures. . . . . . . . . . . . . . . . . . 163
2.3 La structure C++ synonyme de classe . . . . . . . . . . . . . . . . . . . 171
2.4 Conclusion : des classes plutôt que des structures . . . . . . . . . . 177

Chapitre 10
Bibliothèques et espaces de noms
1. Créer une bibliothèque (.h) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
1.1 Contenu du fichier outils.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
1.2 Contenu du fichier outils.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . 182
1.3 Contenu du fichier main.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
2. Espaces de noms (namespace) et raccourcis (using). . . . . . . . . . . . . 187
2.1 Cartographier le code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
2.2 Accéder au contenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
2.3 Répartir le code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
2.4 Limite des répartitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
2.5 Espace de noms dans une bibliothèque . . . . . . . . . . . . . . . . . . . 191
2.6 Imbriquer des espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . . 193
3. La directive using . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
4. Précision sur la liaison entre C++ et C . . . . . . . . . . . . . . . . . . . . . . 196

Chapitre 11
Unions
1. Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
2. Unions discriminées : exemple météo . . . . . . . . . . . . . . . . . . . . . . . . 202
8 Langage C++
L'héritage du C et la programmation orientée objet

Chapitre 12
Tableaux statiques
1. Socle hérité du C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
1.1 Principe du tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
1.2 Disposer d'un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
1.2.1 Définir et déclarer un tableau . . . . . . . . . . . . . . . . . . . . . 210
1.2.2 Des constantes pour les tailles . . . . . . . . . . . . . . . . . . . . 211
1.2.3 Accéder aux éléments du tableau avec l'opérateur [ ] . . 211
1.2.4 Débordement de tableau. . . . . . . . . . . . . . . . . . . . . . . . . 212
1.2.5 Initialiser un tableau à la déclaration . . . . . . . . . . . . . . . 212
1.2.6 Parcourir un tableau avec une boucle for . . . . . . . . . . . . 213
1.3 Tableaux à plusieurs dimensions. . . . . . . . . . . . . . . . . . . . . . . . 214
1.3.1 Matrice à deux dimensions . . . . . . . . . . . . . . . . . . . . . . . 214
1.3.2 Tableaux à N dimensions . . . . . . . . . . . . . . . . . . . . . . . . 215
1.3.3 Initialiser à la déclaration . . . . . . . . . . . . . . . . . . . . . . . . 216
1.3.4 Parcourir un tableau à plusieurs dimensions . . . . . . . . . 216
1.4 Tableaux comme champ dans une structure . . . . . . . . . . . . . . 217
1.5 Tableaux de structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
1.6 Tableaux d'unions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
1.7 Tableaux et fonctions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
1.7.1 Tableaux en global avec fonctions dédiées . . . . . . . . . . 227
1.7.2 Pointeur en paramètre. . . . . . . . . . . . . . . . . . . . . . . . . . . 229
2. Apports du C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
2.1 Boucle for (:) "pour chaque" . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
2.2 Tableaux d'objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
2.2.1 Initialiseurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
2.2.2 Fonction reset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
2.3 Tableau dans une classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
2.3.1 La classe fourmi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
2.3.2 La classe fourmiliere . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
Table des matières 9

2.4 Les conteneurs : rapide introduction. . . . . . . . . . . . . . . . . . . . . 243

2.4.1 La classe array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
2.4.2 La classe vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
2.4.3 La classe list . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249

Chapitre 13
Chaînes de caractères
1. Socle hérité du C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
2. Apports du C++ : la classe string . . . . . . . . . . . . . . . . . . . . . . . . . . . 255

Chapitre 14
Pointeurs
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
2. Brève description théorique du pointeur. . . . . . . . . . . . . . . . . . . . . . 259
2.1 Adresse mémoire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
2.2 Une variable pointeur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
2.3 Quatre opérateurs dédiés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
2.4 Cinq utilisations fondamentales . . . . . . . . . . . . . . . . . . . . . . . . 262
2.4.1 En paramètre de fonction . . . . . . . . . . . . . . . . . . . . . . . . 262
2.4.2 Allocation dynamique (éléments seuls
ou tableaux d’éléments) . . . . . . . . . . . . . . . . . . . . . . . . . 262
2.4.3 Établir des relations entre structures, classes ou objets 262
2.4.4 Élaborer des listes chaînées, des arbres, des graphes . . . 263
2.4.5 Établir un polymorphisme de classe
(C++ uniquement). . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
3. Socle hérité du C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264
3.1 Déclarer un pointeur dans un programme . . . . . . . . . . . . . . . . 264
3.2 Opérateur adresse : &. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264
3.3 Opérateur étoile : *. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
3.4 Opérateur flèche : -> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
3.5 Opérateur crochet : [ ] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
10 Langage C++
L'héritage du C et la programmation orientée objet

3.6 Priorité des quatre opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . 270

3.7 Fonctions C d'allocation dynamique (déconseillées en C++) 270
3.7.1 La fonction malloc() . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
3.7.2 Libérer la mémoire allouée : la fonction free() . . . . . . . . 272
3.8 Le pointeur générique void* . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
3.9 La valeur NULL (déconseillée en C++) . . . . . . . . . . . . . . . . . . 275
3.10 Pointeurs et constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
3.10.1 Pointeur variable sur un objet constant . . . . . . . . . . . . . 276
3.10.2 Pointeur constant sur un objet variable. . . . . . . . . . . . . 277
3.10.3 Pointeur constant sur un objet constant . . . . . . . . . . . . 277
3.11 Cas des pointeurs de fonction . . . . . . . . . . . . . . . . . . . . . . . . . . 278
3.11.1 Une fonction est une adresse . . . . . . . . . . . . . . . . . . . . . 278
3.11.2 Reconnaître un type de fonction . . . . . . . . . . . . . . . . . . 279
3.11.3 Appeler une fonction via un pointeur du bon type. . . . 280
3.11.4 Cast nécessaire si le pointeur est un void*. . . . . . . . . . . 281
3.11.5 Pourquoi des pointeurs de fonction ? Les callbacks . . . 282
4. Apports du C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
4.1 Type référence (pointeur masqué) . . . . . . . . . . . . . . . . . . . . . . 284
4.1.1 Une référence est constante . . . . . . . . . . . . . . . . . . . . . . 287
4.1.2 Connaître la valeur de la référence . . . . . . . . . . . . . . . . . 288
4.2 Retourner une référence. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
4.2.1 Piège à éviter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290
4.2.2 Masquer un tableau avec une fonction . . . . . . . . . . . . . 291
4.3 Opérateurs new et delete, new[ ] et delete[ ] . . . . . . . . . . . . . . 292
4.4 Précisions sur l'opérateur new (C++2011) . . . . . . . . . . . . . . . 293
4.5 La valeur nullptr (remplace NULL) . . . . . . . . . . . . . . . . . . . . . . 297
4.6 Un souci de rigueur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
Table des matières 11

Chapitre 15
Principales utilisations des pointeurs
1. Pointeur en paramètre (passage par référence) . . . . . . . . . . . . . . . . . 303
1.1 Expérimentation avec pointeur classique . . . . . . . . . . . . . . . . . 303
1.2 Simplification de l'écriture avec des références C++. . . . . . . . 305
1.3 Passage avec référence C++ de structures . . . . . . . . . . . . . . . . 306
1.4 Tableau en paramètre. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
1.4.1 Tableau à une dimension . . . . . . . . . . . . . . . . . . . . . . . . 311
1.4.2 Tableaux à plusieurs dimensions . . . . . . . . . . . . . . . . . . 313
2. Allocation dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
2.1 Structures ou objets dynamiques . . . . . . . . . . . . . . . . . . . . . . . 314
2.1.1 Version structures C . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
2.1.2 Version objets C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
2.2 Utiliser un tableau de pointeurs . . . . . . . . . . . . . . . . . . . . . . . . 321
2.2.1 Tableau de pointeurs de structures C . . . . . . . . . . . . . . 322
2.2.2 Tableau de pointeurs d'objets C++. . . . . . . . . . . . . . . . 326
2.3 Validité d'une adresse mémoire . . . . . . . . . . . . . . . . . . . . . . . . . 329
3. Allocation dynamique de tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . 331
3.1 Tableaux dynamiques une dimension. . . . . . . . . . . . . . . . . . . . 331
3.1.1 Tableau dynamique de int . . . . . . . . . . . . . . . . . . . . . . . 331
3.1.2 Tableau dynamique dans une classe . . . . . . . . . . . . . . . 332
3.2 Tableaux dynamiques de plusieurs dimensions . . . . . . . . . . . . 340
3.2.1 Allocation dynamique d'une matrice de int. . . . . . . . . . 340
3.2.2 Allocation dynamique d'une forme
à 6 dimensions de points. . . . . . . . . . . . . . . . . . . . . . . . . 342
4. Associer des structures ou des classes . . . . . . . . . . . . . . . . . . . . . . . . 345
4.1 Association de deux structures C de types différents . . . . . . . 345
4.1.1 Structures avion et pilote . . . . . . . . . . . . . . . . . . . . . . . . 345
4.1.2 Relier avion et pilote . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
4.1.3 Délier un avion et un pilote . . . . . . . . . . . . . . . . . . . . . . 346
4.1.4 Constructeurs avion et pilote . . . . . . . . . . . . . . . . . . . . . 347
4.1.5 Afficher Avion et Pilote. . . . . . . . . . . . . . . . . . . . . . . . . . 348
12 Langage C++
L'héritage du C et la programmation orientée objet

4.1.6 Détruire un Avion ou un Pilote . . . . . . . . . . . . . . . . . . . 349

4.1.7 Main action . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
4.2 Association de structures C de même type. . . . . . . . . . . . . . . . 355
5. Élaborer une liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359

Chapitre 16
Gestion des erreurs
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
2. Socle hérité du C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
2.1 Retourner un booléen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
2.2 Retourner un numéro d'erreur . . . . . . . . . . . . . . . . . . . . . . . . . . 375
2.3 Afficher des informations au moment de l'erreur . . . . . . . . . . 377
3. Fonctionnement et syntaxe des exceptions C++ . . . . . . . . . . . . . . 382
3.1 Instruction throw. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
3.2 Instruction de saut try-catch . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
3.3 Instruction throw et appels de fonctions . . . . . . . . . . . . . . . . . 384
3.4 Instruction throw sans valeur de retour . . . . . . . . . . . . . . . . . . 386
3.5 Bloc catch(...) par défaut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386
3.6 Exception non gérée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
3.7 La fonction terminate. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
3.8 La fonction unexpected . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
4. Utilisation de la classe exception. . . . . . . . . . . . . . . . . . . . . . . . . . . . 392
4.1 Utiliser les exceptions standards du C++ . . . . . . . . . . . . . . . . 392
4.2 Mise à jour de outils.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
4.2.1 Formalisme et style de la présentation . . . . . . . . . . . . . 396
4.2.2 Contrôle d'erreur dans la fonction GetStdout . . . . . . . . 396
4.2.3 Contrôle d'une taille minimum de fenêtre
pour ConsoleResize() . . . . . . . . . . . . . . . . . . . . . . . . . . . 397
4.2.4 Possibles exceptions dans ConsoleResize() . . . . . . . . . . 398
4.3 Conseil sur les exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
Table des matières 13

Chapitre 17
Deux automates cellulaires
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407
2. Simulation de feux de forêt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
2.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
2.2 Mise en forme et initialisation. . . . . . . . . . . . . . . . . . . . . . . . . . 409
2.2.1 Structures de données . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
2.2.2 Dimensionner la console et les deux matrices . . . . . . . . 410
2.2.3 Initialisation des bois. . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
2.2.4 Initialisation du feu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
2.3 Afficher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
2.3.1 Premier type d'affichage, lent . . . . . . . . . . . . . . . . . . . . . 413
2.3.2 Affichage très rapide direct mémoire . . . . . . . . . . . . . . . 414
2.4 Processus générateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416
2.4.1 Fonction de propagation . . . . . . . . . . . . . . . . . . . . . . . . . 416
2.4.2 Boucle du processus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
2.4.3 Destruction des matrices . . . . . . . . . . . . . . . . . . . . . . . . 419
2.5 Texte complet du programme . . . . . . . . . . . . . . . . . . . . . . . . . . 419
2.6 Perspectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430
3. Automate cellulaire type Conway. . . . . . . . . . . . . . . . . . . . . . . . . . . 430
3.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430
3.2 Mise en forme et initialisation. . . . . . . . . . . . . . . . . . . . . . . . . . 431
3.2.1 Structures de données de l'automate . . . . . . . . . . . . . . . 431
3.2.2 Déterminer la taille de la fenêtre console. . . . . . . . . . . . 431
3.2.3 Allocation et initialisation des matrices. . . . . . . . . . . . . 432
3.3 Processus générateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
3.3.1 Fonction calcul. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
3.3.2 Comptage des voisins . . . . . . . . . . . . . . . . . . . . . . . . . . . 434
3.3.3 Recopie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
3.4 Afficher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
3.4.1 Première version : affichage lent. . . . . . . . . . . . . . . . . . . 435
3.4.2 Affichage direct mémoire : rapide . . . . . . . . . . . . . . . . . 436
14 Langage C++
L'héritage du C et la programmation orientée objet

3.5 Texte complet du programme . . . . . . . . . . . . . . . . . . . . . . . . . . 436

3.6 Possibles gels ou mort de l'automate . . . . . . . . . . . . . . . . . . . . 442

Partie 2 : La dimension objet du C++

Chapitre 18
Classes, objets
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
2. Une classe, des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
2.1 Qu'est-ce qu’une classe ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
2.2 Qu'est-ce qu’un objet ?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446
2.3 Définir une classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446
2.4 Déclarer un objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
2.5 Droits d'accès . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448
2.6 Le pointeur this. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449
3. Un programme C muté en classe et objet. . . . . . . . . . . . . . . . . . . . . 450
4. Retour sur la conception du programme . . . . . . . . . . . . . . . . . . . . . 457
4.1 La dimension objet de l'automate . . . . . . . . . . . . . . . . . . . . . . . 457
4.2 La dimension objet de la fenêtre console . . . . . . . . . . . . . . . . . 461
5. Constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462
5.1 Syntaxe d'un constructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462
5.2 Constructeur sans paramètre. . . . . . . . . . . . . . . . . . . . . . . . . . . 463
5.3 Constructeurs avec paramètres . . . . . . . . . . . . . . . . . . . . . . . . . 464
5.4 Constructeur et initialiseur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468
5.4.1 Une seule variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468
5.4.2 Plusieurs variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470
5.4.3 Des variables de types différents . . . . . . . . . . . . . . . . . . 471
5.4.4 Exemple classe Tab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472
5.4.5 L'initialiseur initialise les constantes dans une classe . . 474
5.5 Constructeur par défaut. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475
Table des matières 15

6. Constructeur de copie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476

6.1 Copier un objet à la déclaration. . . . . . . . . . . . . . . . . . . . . . . . . 476
6.2 Problème des données dynamiques . . . . . . . . . . . . . . . . . . . . . . 477
6.3 Implémenter son constructeur de copie . . . . . . . . . . . . . . . . . . 480
7. Constructeur de déplacement (C++2011). . . . . . . . . . . . . . . . . . . . 483
7.1 Lvalue et Rvalue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484
7.2 Problème de transfert lors des passages d'arguments . . . . . . . . 485
7.3 Déclarateur de référence Rvalue && . . . . . . . . . . . . . . . . . . . . 488
7.4 Conversions en Rvalue : static_cast<>(),
fonctions move() et forward<>(). . . . . . . . . . . . . . . . . . . . . . . 489
7.5 Constructeur de déplacement . . . . . . . . . . . . . . . . . . . . . . . . . . 496
7.6 Constructeur de déplacement
avec des données dynamiques . . . . . . . . . . . . . . . . . . . . . . . . . . 498
8. Affectation (operateur =) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502
8.1 Affectation de copie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502
8.2 Affectation de déplacement (C++2011) . . . . . . . . . . . . . . . . . 507
9. Destructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513
9.1 Libérer la mémoire allouée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513
9.2 Destructeur appelé avec delete . . . . . . . . . . . . . . . . . . . . . . . . . 515
9.3 Programme complet de l'automate en objet C++ . . . . . . . . . 517
10. default et delete pour les fonctions spéciales
de classe (C++2011) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
10.1 Fonctions spéciales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
10.2 Utiliser default . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
10.3 Utiliser delete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 529
11. Accesseurs (property en anglais) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530
11.1 Accéder à des données private, encapsulées . . . . . . . . . . . . . . . 530
11.2 Lire une variable private ou protected. . . . . . . . . . . . . . . . . . . . 531
11.3 Modifier une variable private ou protected . . . . . . . . . . . . . . . 532
11.4 Lire et modifier une variable private ou protected . . . . . . . . . . 533
11.5 Intérêt d'un appel de fonction . . . . . . . . . . . . . . . . . . . . . . . . . . 534
12. L’instruction friend ("ami") . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535
16 Langage C++
L'héritage du C et la programmation orientée objet

13. Mise en pratique classe, objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538

13.1 Le pingouin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538
13.2 Aspirateur drone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 539
13.3 Sous-marin nucléaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 540
13.4 Ascenseur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542

Chapitre 19
Surcharge des opérateurs
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545
2. Fonction operator globale hors classe . . . . . . . . . . . . . . . . . . . . . . . . 546
3. Fonction operator localisée dans une classe . . . . . . . . . . . . . . . . . . . 547
3.1 Operator+ sans retour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 548
3.2 Operator+ avec retour de l'objet courant (*this). . . . . . . . . . . 549
3.3 Opérator+ avec retour d'un nouvel objet résultant. . . . . . . . . 551
4. Fonction operator et données dynamiques. . . . . . . . . . . . . . . . . . . . 552
4.1 Surcharge operator+ dans la classe Tab . . . . . . . . . . . . . . . . . . 553
4.2 Surcharge de l'opérateur d'affectation =. . . . . . . . . . . . . . . . . . 555
5. Objet-fonction (ou fonction-objet) . . . . . . . . . . . . . . . . . . . . . . . . . . 561

Chapitre 20
Classes et membres static
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563
2. Qualificatif static en C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564
3. Qualificatif static et objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565
4. Exemple : static pour une classe Console . . . . . . . . . . . . . . . . . . . . . 566
4.1 Utiliser le patron de conception "Singleton". . . . . . . . . . . . . . . 567
4.2 Singleton pour une classe console . . . . . . . . . . . . . . . . . . . . . . . 570
Table des matières 17

5. Mise à jour de la bibliothèque outils.h . . . . . . . . . . . . . . . . . . . . . . . 575

5.1 Création du namespace OutilsCCP de outils.h . . . . . . . . . . . . 575
5.2 Création du namespace OutilsC de outils.h . . . . . . . . . . . . . . . 582

Chapitre 21
Classes génériques
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 589
2. Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590
3. Syntaxe de base. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590
4. Syntaxe des constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 591
5. Syntaxe avec plusieurs types génériques. . . . . . . . . . . . . . . . . . . . . . 592
6. Paramétrage d’une classe générique. . . . . . . . . . . . . . . . . . . . . . . . . . 592
7. Exemple d'implémentation d'une pile générique . . . . . . . . . . . . . . . 598
8. Spécialisation de fonction sur un type donné. . . . . . . . . . . . . . . . . . 601
9. Spécialiser une classe entière . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603
9.1 Spécialisation partielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603
9.2 Spécialisation complète . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605

Chapitre 22
Classe d'objets changeants
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607
2. Rappel union discriminée. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607
3. Principe de l'union illimitée : exemple météo mis à jour . . . . . . . . . 609
18 Langage C++
L'héritage du C et la programmation orientée objet

Chapitre 23
Associations entre objets
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623
2. Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623
3. Principes des associations pour les relations entre objets . . . . . . . . 625
3.1 Association simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
3.2 Agrégation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
3.3 Composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 626
3.4 Problème syntaxique en C++. . . . . . . . . . . . . . . . . . . . . . . . . . 626
4. Associations simples : messages entre objets . . . . . . . . . . . . . . . . . . 627
4.1 Liaison non réciproque entre deux objets . . . . . . . . . . . . . . . . . 627
4.2 Liaison réciproque entre deux objets. . . . . . . . . . . . . . . . . . . . . 629
5. Agrégations : coopération entre objets . . . . . . . . . . . . . . . . . . . . . . . 632
5.1 Liaison à sens unique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 633
5.1.1 Cas général, syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 633
5.1.2 Guitariste et guitare . . . . . . . . . . . . . . . . . . . . . . . . . . . . 634
5.2 Partage d'objets pointés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636
5.2.1 Musiciens simultanés . . . . . . . . . . . . . . . . . . . . . . . . . . . 636
5.2.2 Plusieurs musiciens successifs. . . . . . . . . . . . . . . . . . . . . 638
6. Liaisons réciproques entre objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . 640
6.1 Problème de syntaxe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 640
6.2 Déclaration de type incomplet . . . . . . . . . . . . . . . . . . . . . . . . . 641
6.3 Limite du type incomplet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642
6.4 Résolution du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 644
6.5 Piège d'une liaison réciproque . . . . . . . . . . . . . . . . . . . . . . . . . . 648
6.6 Exemple Terminator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 652
7. Composition : dépendance entre objets . . . . . . . . . . . . . . . . . . . . . . 654
7.1 De l'agrégation à la composition . . . . . . . . . . . . . . . . . . . . . . . . 654
7.2 Techniques envisageables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655
7.3 Pointeur d'objet en propriété . . . . . . . . . . . . . . . . . . . . . . . . . . . 655
7.4 Objet en propriété . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657
Table des matières 19

7.5 Référence d'objet en propriété . . . . . . . . . . . . . . . . . . . . . . . . . . 661

8. Mise en pratique relations entre objets . . . . . . . . . . . . . . . . . . . . . . . 663
8.1 Récapitulation et rappels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663
8.2 Associations simples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 664
8.3 Agrégations et compositions . . . . . . . . . . . . . . . . . . . . . . . . . . . 667

Chapitre 24
Héritage
1. Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 671
2. Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 672
3. Définir une classe dérivée. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 673
4. Appeler explicitement un constructeur de la classe de base . . . . . . 675
5. Redéfinition de données ou de fonctions . . . . . . . . . . . . . . . . . . . . . 676
6. Spécifier un membre de la classe de base . . . . . . . . . . . . . . . . . . . . . 678
7. Droits d'accès locaux de la classe héritée. . . . . . . . . . . . . . . . . . . . . . 679
8. Droits d'accès globaux de la classe héritée . . . . . . . . . . . . . . . . . . . . 682
9. Héritage multiple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 687
9.1 Principe et syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 687
9.2 Exemple : InDominusRex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 688
9.3 Relations transversales dans un arbre de classes . . . . . . . . . . . 691
9.4 Héritage multiple avec une base virtuelle . . . . . . . . . . . . . . . . . 694
10. Distinction entre héritage et association . . . . . . . . . . . . . . . . . . . . . 698
11. Mise en pratique héritage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 699
11.1 Comment identifier un héritage ? . . . . . . . . . . . . . . . . . . . . . . . 699
11.2 Les exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 700
20 Langage C++
L'héritage du C et la programmation orientée objet

Chapitre 25
Polymorphisme et virtualité
1. Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 707
2. Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 708
3. Accès pointeurs limité par son type . . . . . . . . . . . . . . . . . . . . . . . . . 708
4. Autorisation d'accès pour les fonctions virtuelles . . . . . . . . . . . . . . 710
5. Destructeur virtuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711
6. Intérêt des fonctions virtuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 712
7. Exemple : virtualité dans la classe standard exception . . . . . . . . . . 715

Chapitre 26
Classe abstraite et interface
1. Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 721
2. Classe abstraite, fonctions virtuelles pures. . . . . . . . . . . . . . . . . . . . 722
3. Tronc commun pour dériver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 724
4. Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 728
5. Résumé classe abstraite et interface . . . . . . . . . . . . . . . . . . . . . . . . . 731
6. Expérimentation : exemples des super héros, les Avengers . . . . . . . 732
6.1 Classe de base super héros, interface
des fonctions d'action. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 733
6.2 Une dérivée pour chaque Avengers . . . . . . . . . . . . . . . . . . . . . . 738
6.3 Souhait du polymorphisme et impossibilité. . . . . . . . . . . . . . . 742
6.4 Virtualité, intérêt de l'interface des fonctions d'action . . . . . . 744
6.5 Classe abstraite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 747
6.6 Version finale Avengers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 751
7. Mise en pratique classe abstraite . . . . . . . . . . . . . . . . . . . . . . . . . . . . 758
Table des matières 21

Chapitre 27
Quelques comparaisons entre C et C++
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 765
2. Sur les utilisations de pointeurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 766
2.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 766
2.2 Opérateurs de pointeurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 766
2.3 Fonctionnement des opérateurs . . . . . . . . . . . . . . . . . . . . . . . . 767
2.4 Utilisation 1 : en paramètre de fonction . . . . . . . . . . . . . . . . . . 769
2.5 Utilisation 2 : mise en relation d’éléments . . . . . . . . . . . . . . . . 772
2.6 Utilisation 3 : allocation dynamique. . . . . . . . . . . . . . . . . . . . . 775
3. Sur l'utilisation des paramètres et retours de fonctions . . . . . . . . . . 783
3.1 Encapsulation des données C et C++ . . . . . . . . . . . . . . . . . . . 783
3.2 Généralisation du code C et C++ . . . . . . . . . . . . . . . . . . . . . . 784
3.3 Paramètres et retours C++ : la communication entre objets 785
4. Sur l'utilisation de l'union . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 785
4.1 Principe d'une union hiérarchisée en C . . . . . . . . . . . . . . . . . . . 785
4.2 Traduction en C++ d'une union hiérarchisée . . . . . . . . . . . . . 789
4.3 Exemple : une diversité d'ennemis avec une union en C . . . . . 791
4.4 Traduction C++ avec une base et des dérivées . . . . . . . . . . . 800
4.5 Intérêt spécifique de l'union en C++ . . . . . . . . . . . . . . . . . . . 805
5. Sur l'utilisation du typedef. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 817

Annexe : Priorité et associativité des opérateurs . . . . . . . . . . . . . . . . . . . 819

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 821
 367

Chapitre 16
Gestion des erreurs

1. Introduction
Gestion des erreurs

Le dépistage d'erreurs pendant le fonctionnement d'un programme est un

point capital dès lors que le programme engage des responsabilités impor-
tantes, par exemple dans un avion ou pour l'organisation d'un réseau de trains,
etc. À ma connaissance, d'un point de vue théorique, le fonctionnement d'un
programme n'est jamais assuré. On ne peut pas prouver qu'un programme va
s'exécuter correctement, on peut uniquement le constater. Au niveau du code,
contrôler le bon fonctionnement d'un programme revient la plupart du temps
à vérifier pour chaque étape de son déroulement qu'elle s'est exécutée correc-
tement : si l'étape a bien fonctionné, le processus peut continuer avec l'étape
suivante, sinon il s'interrompe. Plusieurs techniques existent pour contrôler
chacune des étapes d'un programme et ce chapitre propose d'expérimenter les
plus communes. Bien entendu, la totalité des opérations réalisées dans un
programme ne va pas être contrôlée. En général, le programmeur prend à sa
charge uniquement les opérations sensibles liées à son propre code ou à l'utili-
sation de fonctions délicates puisées dans différentes bibliothèques.
368 Langage C++
L'héritage du C et la programmation orientée objet

2. Socle hérité du C

2.1 Retourner un booléen

La version la plus simple du contrôle d'erreur consiste à retourner TRUE si

tout va bien et FALSE en cas d'erreur. Dans maFonction() ci-dessous, les
instructions susceptibles de provoquer une erreur, en général des appels à
d'autres fonctions appartenant à une bibliothèque, sont encadrées par un test.
Dans cet exemple, si autreFonction() faisant l'objet du test retourne une
erreur, le test est vrai et l'instruction return FALSE provoque une sortie qui
signale une erreur. S'il n'y a pas d'erreur, maFonction() continue de s'exécuter
normalement jusqu'à l'instruction return TRUE qui indique une fin sans
erreur :
bool maFonction()
{
if( autreFonction() == RetourneUneErreur)
return FALSE;

//suite du programme si tout va bien

// pour indiquer une sortie sans erreur

return TRUE;
}

Exemple fonction ConsoleResize()

Nous écrivons une fonction qui permet de modifier la dimension de la fenêtre

console depuis le code. Cette fonction nécessite un certain nombre de
contrôles d'erreurs.
Toutes les informations concernant une fenêtre console sont organisées et

© Editions ENI - All rights reserved

sauvegardées dans une structure C :
typedef struct _CONSOLE_SCREEN_BUFFER_INFO {
COORD dwSize;
COORD dwCursorPosition;
WORD wAttributes;
SMALL_RECT srWindow;
COORD dwMaximumWindowSize;
} CONSOLE_SCREEN_BUFFER_INFO;
Gestion des erreurs 369
Chapitre 16

dwSize est une structure COORD constituée de deux entiers X et Y. Elle

contient la taille de la fenêtre.
dwCursorPosition contient la position du curseur en écriture.
wAttributes, de type WORD, est en fait une union qui désigne les caracté-
ristiques des caractères par défaut de remplissage de la fenêtre (en relation
avec le type CHAR_INFO).
srWindow correspond à la partie visible de la fenêtre.
dwMaximumWindowSize donne la taille maximum que peut prendre la
fenêtre.
Pour redimensionner la fenêtre console, nous avons besoin de cinq fonctions
de la bibliothèque windows.h :
GetStdHandle() nous permet de récupérer un pointeur qui contient l'adresse
de la fenêtre courante.
GetLargestConsoleWindowSize() nous retourne une structure COORD
avec la taille maximum que peut supporter la console.
GetConsoleScreenBufferInfo() donne toutes les informations d'une
fenêtre dans une structure CONSOLE_SCREEN_BUFFER_INFO.
SetConsoleWindowInfo() permet de redimensionner la taille du rectangle
pour la partie visible de la fenêtre.
SetConsoleScreenBufferSize() redimensionne la zone mémoire afférente à
la fenêtre.
Une fenêtre console est constituée d'une partie visible d'une part, et d'autre
part de la partie mémoire qui peut être plus grande que la partie visible, mais
qui ne peut pas être plus petite.
Modifier les tailles de la fenêtre nécessite de faire attention :
– En cas de diminution de la taille, il faut commencer par rapetisser la partie
visible et ensuite la partie mémoire.
– En cas d'augmentation de la taille, c'est l'inverse : d'abord augmenter la mé-
moire et ensuite augmenter la partie visible.
370 Langage C++
L'héritage du C et la programmation orientée objet

– Nous sommes obligés de traiter tous les cas possibles : largeur et hauteur
peuvent être diminuées toutes les deux, ou augmentées toutes les deux, ou
l'une augmentée et l'autre diminuée. Pour ce faire, nous commençons par
traiter la hauteur qui peut être soit diminuée, soit augmentée et de même
ensuite avec la largeur.
La fonction ConsoleResize() prend en paramètre les largeur et hauteur deman-
dées, elle retourne un booléen qui indique avec false une sortie sur erreur et
avec true la réussite du processus. Voici la fonction complète :
bool ConsoleResize(int width, int height)
{
CONSOLE_SCREEN_BUFFER_INFO info;
COORD max;
// un HANDLE est un synonyme de void* défini dans windows.h
HANDLE h;

// récupérer un handle sur la fenêtre concernée

h = GetStdHandle(STD_OUTPUT_HANDLE);
if (h == INVALID_HANDLE_VALUE)
return FALSE;

// récupération de la taille maximum supportée par la

// console
max = GetLargestConsoleWindowSize(h));
width = (width > max.X) ? max.X : ((width < 1) ? 1 : width);
height=(height > max.Y)? max.Y : ((height < 1)? 1 : height);

if (!GetConsoleScreenBufferInfo(h, &info))
return FALSE;

// si la hauteur demandée est inférieure à la hauteur

// actuelle
if (height < info.dwSize.Y) {

© Editions ENI - All rights reserved

// diminuer d'abord le rectangle fenêtre
info.srWindow.Bottom = height - 1;
if (!SetConsoleWindowInfo(h, TRUE, &info.srWindow))
return FALSE;

// ensuite le buffer correspondant

info.dwSize.Y = height;
if (!SetConsoleScreenBufferSize(h, info.dwSize))
Gestion des erreurs 371
Chapitre 16

return FALSE;

}
// si la taille demandée est supérieure à la taille actuelle
else if (height > info.dwSize.Y) {

// d'abord augmenter la taille du buffer

info.dwSize.Y = height;
if (!SetConsoleScreenBufferSize(h, info.dwSize))
return FALSE;

// ensuite le rectangle correspondant de la fenêtre

info.srWindow.Bottom = height - 1;
if (!SetConsoleWindowInfo(h, TRUE, &info.srWindow))
return FALSE;
}
// idem pour la largeur
if (width < info.dwSize.X) {

info.srWindow.Right = width - 1;
if (!SetConsoleWindowInfo(h, TRUE, &info.srWindow))
return FALSE;

info.dwSize.X = width;
if (!SetConsoleScreenBufferSize(h, info.dwSize))
return FALSE;

}
else if (width > info.dwSize.X) {

info.dwSize.X = width;
if (!SetConsoleScreenBufferSize(h, info.dwSize))
return FALSE;

info.srWindow.Right = width - 1;
if (!SetConsoleWindowInfo(h, TRUE, &info.srWindow))
return FALSE;
}
return TRUE;
}
372 Langage C++
L'héritage du C et la programmation orientée objet

L'algorithme est le suivant :

– Nous récupérons un pointeur sur la fenêtre courante. En cas d'erreur, false
est retourné et la suite n'est pas exécutée.
– Récupération de la taille maximum supportée par la console. À ce moment,
nous contrôlons les valeurs entrées pour la nouvelle taille : trop grandes,
elles sont ramenées à la taille maximum et trop petite à 1, qui est la taille
minimum.
– Récupération des informations sur la fenêtre courante, en cas d'erreur, false
est retourné et la suite n'est pas exécutée.
– Si la hauteur demandée est inférieure à la hauteur actuelle, la hauteur de la
partie visible est diminuée et ensuite la partie mémoire est calibrée sur la
nouvelle hauteur. À chaque fois, en cas d'erreur, false est retourné et la suite
n'est pas exécutée.
– Si la hauteur demandée est supérieure à la hauteur actuelle, la taille de la
zone mémoire est tout d'abord augmentée et ensuite la hauteur de la fenêtre
est ajustée. À chaque fois, en cas d'erreur, false est retourné et la suite n'est
pas exécutée.
– Le principe est exactement le même ensuite pour la largeur.
Dans le main, la valeur de retour de la fonction nous indique s'il y a erreur ou
pas :
if (!ConsoleResize(w, h))
cout << "une erreur est survenue" << endl;

Voici le programme d'expérimentation complet :

// socle hérité du C / retourner un bouléen
#include <iostream>
#include <Windows.h>

© Editions ENI - All rights reserved

using namespace std;

bool ConsoleResize(int width, int height)

{
// récupérer un handle sur la fenêtre concernée
HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
if (h == INVALID_HANDLE_VALUE)
return FALSE;