l’héritage du c et la programmation orientée objet · pour finir, un chapitre compare le c et...

ISBN

: 97

8-2-

409-

0153

0-4

29,9

0 €

Pour plus d’informations :

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 sur le langage C++ s’adresse aux personnes qui débutent avec C++ et ayant déjà programmé dans d’autres langages.

Le livre se divise en deux parties. Dans la première, l’auteur traite de notions qui concernent l’écriture algorithmique et ses fondamentaux : variables, opérations, structures de contrôle (if, switch, boucles, fonc-tions), ensembles de variables (structures et tableaux), pointeurs... En bref, il s’agit du langage C intégré au langage C++. L’auteur expose les correctifs et les élargissements fonctionnels apportés par le C++. Les classes et les objets commencent à apparaître avec la notion de struc-tures. Les améliorations apportées par le C++ sont mises en pratique dans 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 s’orienter franchement vers la programmation et l’architecture objet des programmes. Il y détaille les notions de classes (constructeurs, destruc-teurs), d’objets, la problématique de relations entre objets, l’héritage, la 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 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 pour s’approprier le langage. Les éléments nécessaires à la réalisation des exercices sont en téléchargement sur le site www.editions-eni.fr.

Téléchargementwww.editions-eni.fr.fr

sur www.editions-eni.fr : b Le code source des programmes d’illustration.

Partie C++ hérité du C : Introduction • Pre-miers programmes • Variables simples, constantes, affectation • Affichage et saisie 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 • 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 entre objets • Héritage • Polymorphisme et virtualité • Classe abstraite et interface • Quelques comparaisons entre C et C++

Frédéric DROUILLON est enseignant, chercheur et aussi créateur dans le domaine de l’informatique et des arts numériques. Il envisage la programma-tion et ses langages comme un moyen d’expression et de formulation d’idées, une véritable écriture, qui nécessite de la recherche et de la créativité. L’objectif de son enseignement en langage C++ est de permettre au lecteur d’acquérir un savoir-faire fondamental en programma-tion informatique pour ensuite circuler le plus librement possible dans les diffé-rentes techniques et langages de pro-grammation.

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

Les chapitres du livre

Lang

age

C++

Hérit

age

du C

et p

rogr

amm

atio

n or

ient

ée o

bjet

Langage C++ L’héritage du C

et la programmation orientée objet

(avec programmes d’illustration et exercices)

Frédéric DROUILLON

1Table des matières

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 1Premiers 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++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384.1 Bibliothèque <iostream>, directive #include . . . . . . . . . . . . . . 394.2 L'instruction using namespace std; . . . . . . . . . . . . . . . . . . . . . . . 404.3 Inclusion des bibliothèques C en C++. . . . . . . . . . . . . . . . . . . . 41

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.

lcroise

Tampon

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

Langage C++

Chapitre 2Variables simples, constantes, affectation

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

2. Socle C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442.1 Différents types de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442.2 Déclaration des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452.3 Affecter et afficher une valeur (avec cout qui est C++) . . . . . . 462.4 Caractères, codage ASCII . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472.5 Variables constantes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492.6 Énumérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502.7 Directive #define . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512.8 Opérateur Sizeof. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

3. Apports C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533.1 Déclarations plus souples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533.2 Type bool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533.3 Type long long ou unsigned long long . . . . . . . . . . . . . . . . . . . . 543.4 Type caractère unicode : wchar_t . . . . . . . . . . . . . . . . . . . . . . . . 553.5 Type auto (C++ 2011) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563.6 Constantes (const) et énumération (enum)

plutôt que #define . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

Chapitre 3Affichage et saisie console

1. Socle C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 591.1 Fonction printf (déconseillé en C++) . . . . . . . . . . . . . . . . . . . . 591.2 Fonctions sprintf et snprintf . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621.3 Fonction scanf (déconseillé en C++) . . . . . . . . . . . . . . . . . . . . . 63


2. Apports C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642.1 Utiliser cout et cin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642.2 Instructions de formatage en sortie. . . . . . . . . . . . . . . . . . . . . . . 66

2.2.1 Largeur minimum de l'affichage . . . . . . . . . . . . . . . . . . . . 662.2.2 Alignement des sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . 672.2.3 Choisir un caractère de remplissage . . . . . . . . . . . . . . . . . 672.2.4 Afficher ou non les zéros après la virgule. . . . . . . . . . . . . 682.2.5 Afficher le signe des nombres positifs . . . . . . . . . . . . . . . 69

Chapitre 4Opérations

1. Socle C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711.1 Notion d'expression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711.2 Opérations arithmétiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 721.3 Valeurs aléatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

1.3.1 Avoir des suites différentes . . . . . . . . . . . . . . . . . . . . . . . . 741.3.2 Définir une fourchette. . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

1.4 Opérations bit à bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 751.4.1 ET : opérateur & . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 751.4.2 OU exclusif : opérateur ^ . . . . . . . . . . . . . . . . . . . . . . . . 771.4.3 OU inclusif : opérateur |. . . . . . . . . . . . . . . . . . . . . . . . . . 771.4.4 Complément : opérateur ~. . . . . . . . . . . . . . . . . . . . . . . . 781.4.5 Décalages gauche et droite : opérateurs >> et << . . . . 781.4.6 Priorités des opérateurs bit à bit . . . . . . . . . . . . . . . . . . . . 78

2. Apports C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 792.1 Surcharger les opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79


Langage C++

Chapitre 5Conversions de types

1. Socle hérité du C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 811.1 Le principe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 811.2 Opérateur de conversion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 821.3 Exemple : nombre aléatoire avec décimales . . . . . . . . . . . . . . . . 83

2. Apports du C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 842.1 static_cast<type> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 842.2 const_cast<type> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 852.3 reinterpret_cast<type>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 862.4 dynamic_cast<type> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

Chapitre 6Structures de contrôle

1. Socle hérité du C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 891.1 Bloc d'instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 901.2 L'instruction conditionnelle if . . . . . . . . . . . . . . . . . . . . . . . . . . . 901.3 Définir une condition. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

1.3.1 Opérateurs de comparaisons. . . . . . . . . . . . . . . . . . . . . . . 921.3.2 L'opérateur unaire NON : ! . . . . . . . . . . . . . . . . . . . . . . . . 93

1.4 Le couple d'instructions if-else. . . . . . . . . . . . . . . . . . . . . . . . . . . 931.5 La forme contractée du if-else, opérateur conditionnel "?" . . . . 951.6 La cascade d'instructions if - else if - else . . . . . . . . . . . . . . . . . . 961.7 Les tests multiconditions (ET/OU). . . . . . . . . . . . . . . . . . . . . . . 97

1.7.1 Conjonction ET : opérateur &&. . . . . . . . . . . . . . . . . . . . 971.7.2 ET avec plus de deux expressions membres. . . . . . . . . . . 981.7.3 Disjonction OU, opérateur || . . . . . . . . . . . . . . . . . . . . . 991.7.4 OU avec plus de deux expressions membres . . . . . . . . . 1001.7.5 ET prioritaire sur OU . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

1.8 Branchement : switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1011.9 Rupture de séquence : goto avec étiquette . . . . . . . . . . . . . . . . 104


1.10 Les trois boucles : while, do-while et for. . . . . . . . . . . . . . . . . . 1051.10.1 Boucle TANT QUE : le while . . . . . . . . . . . . . . . . . . . . . 1051.10.2 Boucle FAIRE {...} TANT QUE : le do-while . . . . . . . . 1071.10.3 Boucle comptée POUR : le for . . . . . . . . . . . . . . . . . . . . 1071.10.4 Boucles imbriquées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

1.11 Sortie et saut forcés dans une boucle . . . . . . . . . . . . . . . . . . . . 1111.11.1 Sortir avec l'instruction break. . . . . . . . . . . . . . . . . . . . . 1111.11.2 Passer à l'itération suivante

avec l'instruction continue . . . . . . . . . . . . . . . . . . . . . . . 1121.11.3 Sortir d'une ou de plusieurs boucles imbriquées

avec l'instruction goto . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

2. Apports du C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1132.1 Boucle for (:) "pour chaque" . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

Chapitre 7Fonctions

1. Socle hérité du C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1151.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1151.2 Exemple de fonction sans retour et sans paramètre. . . . . . . . . 1161.3 Déclaration et visibilité d'une fonction . . . . . . . . . . . . . . . . . . . 1181.4 Exemples de fonction avec paramètres . . . . . . . . . . . . . . . . . . . 120

1.4.1 Déplacer le curseur en écriture de la fenêtre console. . . 1201.4.2 Changer la couleur des caractères. . . . . . . . . . . . . . . . . . 1211.4.3 À propos de la couleur en console. . . . . . . . . . . . . . . . . . 1221.4.4 Afficher une lettre à une position

et d'une couleur donnée dans la console . . . . . . . . . . . . 1231.4.5 Tracer une ligne horizontale . . . . . . . . . . . . . . . . . . . . . . 1231.4.6 Le programme complet . . . . . . . . . . . . . . . . . . . . . . . . . . 124

1.5 Exemples de fonction avec retour . . . . . . . . . . . . . . . . . . . . . . . 1261.5.1 Retourner un nombre aléatoire entre 0 et 1. . . . . . . . . . 1261.5.2 Retourner le résultat d'un jeté de deux dés à six faces . 1261.5.3 Programme complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127


Langage C++

1.6 Exemple de fonction avec retour et avec paramètres . . . . . . . . 1281.6.1 Conversion chiffres romains . . . . . . . . . . . . . . . . . . . . . 128

2. Apports du C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1312.1 Fonctions embarquées "inline". . . . . . . . . . . . . . . . . . . . . . . . . . 1312.2 Valeurs par défaut de paramètres . . . . . . . . . . . . . . . . . . . . . . . 1322.3 Surcharge des fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1332.4 Fonctions génériques (template) . . . . . . . . . . . . . . . . . . . . . . . . 135

Chapitre 8Portée et durée de vie des variables

1. Règles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

2. Masquage d'une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

3. Variables static . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

Chapitre 9Structures

1. Socle hérité du C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1451.1 Principe de la structure. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1451.2 Disposer d'une structure / entite 1 . . . . . . . . . . . . . . . . . . . . . . 146

1.2.1 Définir un type de structure . . . . . . . . . . . . . . . . . . . . . . 1461.2.2 Déclarer une variable structure. . . . . . . . . . . . . . . . . . . . 1461.2.3 Initialiser à la déclaration . . . . . . . . . . . . . . . . . . . . . . . . 1471.2.4 Accéder aux éléments avec l'opérateur point. . . . . . . . . 147

1.3 Utiliser un typedef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1501.4 Structures en retour ou en paramètre de fonction . . . . . . . . . . 153

1.4.1 Fonction d'initialisation d'une entite . . . . . . . . . . . . . . . 1531.4.2 Fonctions d'affichage et d'effacement . . . . . . . . . . . . . . 1541.4.3 Fonction pour avancer. . . . . . . . . . . . . . . . . . . . . . . . . . . 1541.4.4 Boucle événementielle . . . . . . . . . . . . . . . . . . . . . . . . . . . 1561.4.5 Contrôle du rythme de l'animation . . . . . . . . . . . . . . . . 1561.4.6 Rendre invisible le curseur en écriture . . . . . . . . . . . . . . 157


1.4.7 Programme complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1581.5 Structures imbriquées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

2. Apports du C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1632.1 typedef inutile pour les structures. . . . . . . . . . . . . . . . . . . . . . . 1632.2 Fonctions comme champs de structures. . . . . . . . . . . . . . . . . . 1632.3 La structure C++ synonyme de classe . . . . . . . . . . . . . . . . . . . 1712.4 Conclusion : des classes plutôt que des structures . . . . . . . . . . 177

Chapitre 10Bibliothèques et espaces de noms

1. Créer une bibliothèque (.h) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1791.1 Contenu du fichier outils.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1811.2 Contenu du fichier outils.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . 1821.3 Contenu du fichier main.cpp. . . . . . . . . . . . . . . . . . . . . . . . . . . 183

2. Espaces de noms (namespace) et raccourcis (using). . . . . . . . . . . . . 1872.1 Cartographier le code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1872.2 Accéder au contenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1872.3 Répartir le code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1882.4 Limite des répartitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1902.5 Espace de noms dans une bibliothèque . . . . . . . . . . . . . . . . . . . 1912.6 Imbriquer des espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . . 193

3. La directive using . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194

4. Précision sur la liaison entre C++ et C . . . . . . . . . . . . . . . . . . . . . . 196

Chapitre 11Unions

1. Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199

2. Unions discriminées : exemple météo . . . . . . . . . . . . . . . . . . . . . . . . 202


Langage C++

Chapitre 12Tableaux statiques

1. Socle hérité du C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2091.1 Principe du tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2091.2 Disposer d'un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210

1.2.1 Définir et déclarer un tableau . . . . . . . . . . . . . . . . . . . . . 2101.2.2 Des constantes pour les tailles . . . . . . . . . . . . . . . . . . . . 2111.2.3 Accéder aux éléments du tableau avec l'opérateur [ ] . . 2111.2.4 Débordement de tableau. . . . . . . . . . . . . . . . . . . . . . . . . 2121.2.5 Initialiser un tableau à la déclaration . . . . . . . . . . . . . . . 2121.2.6 Parcourir un tableau avec une boucle for . . . . . . . . . . . . 213

1.3 Tableaux à plusieurs dimensions. . . . . . . . . . . . . . . . . . . . . . . . 2141.3.1 Matrice à deux dimensions . . . . . . . . . . . . . . . . . . . . . . . 2141.3.2 Tableaux à N dimensions . . . . . . . . . . . . . . . . . . . . . . . . 2151.3.3 Initialiser à la déclaration . . . . . . . . . . . . . . . . . . . . . . . . 2161.3.4 Parcourir un tableau à plusieurs dimensions . . . . . . . . . 216

1.4 Tableaux comme champ dans une structure . . . . . . . . . . . . . . 2171.5 Tableaux de structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2201.6 Tableaux d'unions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2241.7 Tableaux et fonctions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227

1.7.1 Tableaux en global avec fonctions dédiées . . . . . . . . . . 2271.7.2 Pointeur en paramètre. . . . . . . . . . . . . . . . . . . . . . . . . . . 229

2. Apports du C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2292.1 Boucle for (:) "pour chaque" . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2292.2 Tableaux d'objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231

2.2.1 Initialiseurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2322.2.2 Fonction reset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233

2.3 Tableau dans une classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2362.3.1 La classe fourmi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2362.3.2 La classe fourmiliere . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240


2.4 Les conteneurs : rapide introduction. . . . . . . . . . . . . . . . . . . . . 2432.4.1 La classe array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2442.4.2 La classe vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2462.4.3 La classe list . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249

Chapitre 13Chaînes de caractères

1. Socle hérité du C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253

2. Apports du C++ : la classe string . . . . . . . . . . . . . . . . . . . . . . . . . . . 255

Chapitre 14Pointeurs

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259

2. Brève description théorique du pointeur. . . . . . . . . . . . . . . . . . . . . . 2592.1 Adresse mémoire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2602.2 Une variable pointeur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2612.3 Quatre opérateurs dédiés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2612.4 Cinq utilisations fondamentales . . . . . . . . . . . . . . . . . . . . . . . . 262

2.4.1 En paramètre de fonction . . . . . . . . . . . . . . . . . . . . . . . . 2622.4.2 Allocation dynamique (éléments seuls

ou tableaux d’éléments) . . . . . . . . . . . . . . . . . . . . . . . . . 2622.4.3 Établir des relations entre structures, classes ou objets 2622.4.4 Élaborer des listes chaînées, des arbres, des graphes . . . 2632.4.5 Établir un polymorphisme de classe

(C++ uniquement). . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263

3. Socle hérité du C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2643.1 Déclarer un pointeur dans un programme . . . . . . . . . . . . . . . . 2643.2 Opérateur adresse : &. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2643.3 Opérateur étoile : * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2663.4 Opérateur flèche : -> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2673.5 Opérateur crochet : [ ] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269


Langage C++

3.6 Priorité des quatre opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . 2703.7 Fonctions C d'allocation dynamique (déconseillées en C++) 270

3.7.1 La fonction malloc() . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2703.7.2 Libérer la mémoire allouée : la fonction free() . . . . . . . . 272

3.8 Le pointeur générique void* . . . . . . . . . . . . . . . . . . . . . . . . . . . 2743.9 La valeur NULL (déconseillée en C++) . . . . . . . . . . . . . . . . . . 2753.10 Pointeurs et constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275

3.10.1 Pointeur variable sur un objet constant . . . . . . . . . . . . . 2763.10.2 Pointeur constant sur un objet variable. . . . . . . . . . . . . 2773.10.3 Pointeur constant sur un objet constant . . . . . . . . . . . . 277

3.11 Cas des pointeurs de fonction . . . . . . . . . . . . . . . . . . . . . . . . . . 2783.11.1 Une fonction est une adresse . . . . . . . . . . . . . . . . . . . . . 2783.11.2 Reconnaître un type de fonction . . . . . . . . . . . . . . . . . . 2793.11.3 Appeler une fonction via un pointeur du bon type. . . . 2803.11.4 Cast nécessaire si le pointeur est un void*. . . . . . . . . . . 2813.11.5 Pourquoi des pointeurs de fonction ? Les callbacks . . . 282

4. Apports du C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2844.1 Type référence (pointeur masqué) . . . . . . . . . . . . . . . . . . . . . . 284

4.1.1 Une référence est constante . . . . . . . . . . . . . . . . . . . . . . 2874.1.2 Connaître la valeur de la référence . . . . . . . . . . . . . . . . . 288

4.2 Retourner une référence. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2894.2.1 Piège à éviter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2904.2.2 Masquer un tableau avec une fonction . . . . . . . . . . . . . 291

4.3 Opérateurs new et delete, new[ ] et delete[ ] . . . . . . . . . . . . . . 2924.4 Précisions sur l'opérateur new (C++2011) . . . . . . . . . . . . . . . 2934.5 La valeur nullptr (remplace NULL) . . . . . . . . . . . . . . . . . . . . . . 2974.6 Un souci de rigueur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299


Chapitre 15Principales utilisations des pointeurs

1. Pointeur en paramètre (passage par référence) . . . . . . . . . . . . . . . . . 3031.1 Expérimentation avec pointeur classique . . . . . . . . . . . . . . . . . 3031.2 Simplification de l'écriture avec des références C++. . . . . . . . 3051.3 Passage avec référence C++ de structures . . . . . . . . . . . . . . . . 3061.4 Tableau en paramètre. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310

1.4.1 Tableau à une dimension . . . . . . . . . . . . . . . . . . . . . . . . 3111.4.2 Tableaux à plusieurs dimensions . . . . . . . . . . . . . . . . . . 313

2. Allocation dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3142.1 Structures ou objets dynamiques . . . . . . . . . . . . . . . . . . . . . . . 314

2.1.1 Version structures C . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3142.1.2 Version objets C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319

2.2 Utiliser un tableau de pointeurs . . . . . . . . . . . . . . . . . . . . . . . . 3212.2.1 Tableau de pointeurs de structures C . . . . . . . . . . . . . . 3222.2.2 Tableau de pointeurs d'objets C++. . . . . . . . . . . . . . . . 326

2.3 Validité d'une adresse mémoire . . . . . . . . . . . . . . . . . . . . . . . . . 329

3. Allocation dynamique de tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . 3313.1 Tableaux dynamiques une dimension. . . . . . . . . . . . . . . . . . . . 331

3.1.1 Tableau dynamique de int . . . . . . . . . . . . . . . . . . . . . . . 3313.1.2 Tableau dynamique dans une classe . . . . . . . . . . . . . . . 332

3.2 Tableaux dynamiques de plusieurs dimensions . . . . . . . . . . . . 3403.2.1 Allocation dynamique d'une matrice de int. . . . . . . . . . 3403.2.2 Allocation dynamique d'une forme

à 6 dimensions de points. . . . . . . . . . . . . . . . . . . . . . . . . 342

4. Associer des structures ou des classes . . . . . . . . . . . . . . . . . . . . . . . . 3454.1 Association de deux structures C de types différents . . . . . . . 345

4.1.1 Structures avion et pilote . . . . . . . . . . . . . . . . . . . . . . . . 3454.1.2 Relier avion et pilote . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3464.1.3 Délier un avion et un pilote . . . . . . . . . . . . . . . . . . . . . . 3464.1.4 Constructeurs avion et pilote . . . . . . . . . . . . . . . . . . . . . 3474.1.5 Afficher Avion et Pilote. . . . . . . . . . . . . . . . . . . . . . . . . . 348


Langage C++

4.1.6 Détruire un Avion ou un Pilote . . . . . . . . . . . . . . . . . . . 3494.1.7 Main action . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350

4.2 Association de structures C de même type. . . . . . . . . . . . . . . . 355

5. Élaborer une liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359

Chapitre 16Gestion des erreurs

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367

2. Socle hérité du C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3682.1 Retourner un booléen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3682.2 Retourner un numéro d'erreur . . . . . . . . . . . . . . . . . . . . . . . . . . 3752.3 Afficher des informations au moment de l'erreur . . . . . . . . . . 377

3. Fonctionnement et syntaxe des exceptions C++ . . . . . . . . . . . . . . 3823.1 Instruction throw. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3823.2 Instruction de saut try-catch . . . . . . . . . . . . . . . . . . . . . . . . . . . 3833.3 Instruction throw et appels de fonctions . . . . . . . . . . . . . . . . . 3843.4 Instruction throw sans valeur de retour . . . . . . . . . . . . . . . . . . 3863.5 Bloc catch(...) par défaut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3863.6 Exception non gérée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3873.7 La fonction terminate. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3893.8 La fonction unexpected . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390

4. Utilisation de la classe exception. . . . . . . . . . . . . . . . . . . . . . . . . . . . 3924.1 Utiliser les exceptions standards du C++ . . . . . . . . . . . . . . . . 3924.2 Mise à jour de outils.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396

4.2.1 Formalisme et style de la présentation . . . . . . . . . . . . . 3964.2.2 Contrôle d'erreur dans la fonction GetStdout . . . . . . . . 3964.2.3 Contrôle d'une taille minimum de fenêtre

pour ConsoleResize() . . . . . . . . . . . . . . . . . . . . . . . . . . . 3974.2.4 Possibles exceptions dans ConsoleResize() . . . . . . . . . . 398

4.3 Conseil sur les exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406


Chapitre 17Deux automates cellulaires

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407

2. Simulation de feux de forêt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4082.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4082.2 Mise en forme et initialisation. . . . . . . . . . . . . . . . . . . . . . . . . . 409

2.2.1 Structures de données . . . . . . . . . . . . . . . . . . . . . . . . . . . 4092.2.2 Dimensionner la console et les deux matrices . . . . . . . . 4102.2.3 Initialisation des bois. . . . . . . . . . . . . . . . . . . . . . . . . . . . 4112.2.4 Initialisation du feu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412

2.3 Afficher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4132.3.1 Premier type d'affichage, lent . . . . . . . . . . . . . . . . . . . . . 4132.3.2 Affichage très rapide direct mémoire . . . . . . . . . . . . . . . 414

2.4 Processus générateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4162.4.1 Fonction de propagation . . . . . . . . . . . . . . . . . . . . . . . . . 4162.4.2 Boucle du processus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4172.4.3 Destruction des matrices . . . . . . . . . . . . . . . . . . . . . . . . 419

2.5 Texte complet du programme . . . . . . . . . . . . . . . . . . . . . . . . . . 4192.6 Perspectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430

3. Automate cellulaire type Conway. . . . . . . . . . . . . . . . . . . . . . . . . . . 4303.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4303.2 Mise en forme et initialisation. . . . . . . . . . . . . . . . . . . . . . . . . . 431

3.2.1 Structures de données de l'automate . . . . . . . . . . . . . . . 4313.2.2 Déterminer la taille de la fenêtre console. . . . . . . . . . . . 4313.2.3 Allocation et initialisation des matrices. . . . . . . . . . . . . 432

3.3 Processus générateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4333.3.1 Fonction calcul. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4333.3.2 Comptage des voisins . . . . . . . . . . . . . . . . . . . . . . . . . . . 4343.3.3 Recopie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435

3.4 Afficher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4353.4.1 Première version : affichage lent. . . . . . . . . . . . . . . . . . . 4353.4.2 Affichage direct mémoire : rapide . . . . . . . . . . . . . . . . . 436


Langage C++

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


6. Constructeur de copie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4766.1 Copier un objet à la déclaration. . . . . . . . . . . . . . . . . . . . . . . . . 4766.2 Problème des données dynamiques . . . . . . . . . . . . . . . . . . . . . . 4776.3 Implémenter son constructeur de copie . . . . . . . . . . . . . . . . . . 480

7. Constructeur de déplacement (C++2011). . . . . . . . . . . . . . . . . . . . 4837.1 Lvalue et Rvalue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4847.2 Problème de transfert lors des passages d'arguments . . . . . . . . 4857.3 Déclarateur de référence Rvalue && . . . . . . . . . . . . . . . . . . . . 4887.4 Conversions en Rvalue : static_cast<>(),

fonctions move() et forward<>(). . . . . . . . . . . . . . . . . . . . . . . 4897.5 Constructeur de déplacement . . . . . . . . . . . . . . . . . . . . . . . . . . 4967.6 Constructeur de déplacement

avec des données dynamiques . . . . . . . . . . . . . . . . . . . . . . . . . . 498

8. Affectation (operateur =) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5028.1 Affectation de copie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5028.2 Affectation de déplacement (C++2011) . . . . . . . . . . . . . . . . . 507

9. Destructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5139.1 Libérer la mémoire allouée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5139.2 Destructeur appelé avec delete . . . . . . . . . . . . . . . . . . . . . . . . . 5159.3 Programme complet de l'automate en objet C++ . . . . . . . . . 517

10. default et delete pour les fonctions spéciales de classe (C++2011) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52710.1 Fonctions spéciales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52710.2 Utiliser default . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52710.3 Utiliser delete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 529

11. Accesseurs (property en anglais) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53011.1 Accéder à des données private, encapsulées . . . . . . . . . . . . . . . 53011.2 Lire une variable private ou protected. . . . . . . . . . . . . . . . . . . . 53111.3 Modifier une variable private ou protected . . . . . . . . . . . . . . . 53211.4 Lire et modifier une variable private ou protected . . . . . . . . . . 53311.5 Intérêt d'un appel de fonction . . . . . . . . . . . . . . . . . . . . . . . . . . 534

12. L’instruction friend ("ami") . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535


Langage C++

13. Mise en pratique classe, objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53813.1 Le pingouin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53813.2 Aspirateur drone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53913.3 Sous-marin nucléaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54013.4 Ascenseur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542

Chapitre 19Surcharge des opérateurs

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545

2. Fonction operator globale hors classe . . . . . . . . . . . . . . . . . . . . . . . . 546

3. Fonction operator localisée dans une classe . . . . . . . . . . . . . . . . . . . 5473.1 Operator+ sans retour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5483.2 Operator+ avec retour de l'objet courant (*this) . . . . . . . . . . . 5493.3 Opérator+ avec retour d'un nouvel objet résultant. . . . . . . . . 551

4. Fonction operator et données dynamiques. . . . . . . . . . . . . . . . . . . . 5524.1 Surcharge operator+ dans la classe Tab . . . . . . . . . . . . . . . . . . 5534.2 Surcharge de l'opérateur d'affectation =. . . . . . . . . . . . . . . . . . 555

5. Objet-fonction (ou fonction-objet) . . . . . . . . . . . . . . . . . . . . . . . . . . 561

Chapitre 20Classes 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 . . . . . . . . . . . . . . . . . . . . . 5664.1 Utiliser le patron de conception "Singleton". . . . . . . . . . . . . . . 5674.2 Singleton pour une classe console . . . . . . . . . . . . . . . . . . . . . . . 570


5. Mise à jour de la bibliothèque outils.h . . . . . . . . . . . . . . . . . . . . . . . 5755.1 Création du namespace OutilsCCP de outils.h . . . . . . . . . . . . 5755.2 Création du namespace OutilsC de outils.h . . . . . . . . . . . . . . . 582

Chapitre 21Classes 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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6039.1 Spécialisation partielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6039.2 Spécialisation complète . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605

Chapitre 22Classe 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


Langage C++

Chapitre 23Associations entre objets

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623

2. Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623

3. Principes des associations pour les relations entre objets . . . . . . . . 6253.1 Association simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6253.2 Agrégation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6253.3 Composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6263.4 Problème syntaxique en C++. . . . . . . . . . . . . . . . . . . . . . . . . . 626

4. Associations simples : messages entre objets . . . . . . . . . . . . . . . . . . 6274.1 Liaison non réciproque entre deux objets . . . . . . . . . . . . . . . . . 6274.2 Liaison réciproque entre deux objets . . . . . . . . . . . . . . . . . . . . . 629

5. Agrégations : coopération entre objets . . . . . . . . . . . . . . . . . . . . . . . 6325.1 Liaison à sens unique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 633

5.1.1 Cas général, syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6335.1.2 Guitariste et guitare . . . . . . . . . . . . . . . . . . . . . . . . . . . . 634

5.2 Partage d'objets pointés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6365.2.1 Musiciens simultanés . . . . . . . . . . . . . . . . . . . . . . . . . . . 6365.2.2 Plusieurs musiciens successifs. . . . . . . . . . . . . . . . . . . . . 638

6. Liaisons réciproques entre objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6406.1 Problème de syntaxe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6406.2 Déclaration de type incomplet . . . . . . . . . . . . . . . . . . . . . . . . . 6416.3 Limite du type incomplet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6426.4 Résolution du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6446.5 Piège d'une liaison réciproque . . . . . . . . . . . . . . . . . . . . . . . . . . 6486.6 Exemple Terminator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 652

7. Composition : dépendance entre objets . . . . . . . . . . . . . . . . . . . . . . 6547.1 De l'agrégation à la composition . . . . . . . . . . . . . . . . . . . . . . . . 6547.2 Techniques envisageables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6557.3 Pointeur d'objet en propriété . . . . . . . . . . . . . . . . . . . . . . . . . . . 6557.4 Objet en propriété . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657


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

8. Mise en pratique relations entre objets . . . . . . . . . . . . . . . . . . . . . . . 6638.1 Récapitulation et rappels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6638.2 Associations simples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6648.3 Agrégations et compositions . . . . . . . . . . . . . . . . . . . . . . . . . . . 667

Chapitre 24Hé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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6879.1 Principe et syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6879.2 Exemple : InDominusRex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6889.3 Relations transversales dans un arbre de classes . . . . . . . . . . . 6919.4 Héritage multiple avec une base virtuelle . . . . . . . . . . . . . . . . . 694

10. Distinction entre héritage et association . . . . . . . . . . . . . . . . . . . . . 698

11. Mise en pratique héritage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69911.1 Comment identifier un héritage ? . . . . . . . . . . . . . . . . . . . . . . . 69911.2 Les exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 700


Langage C++

Chapitre 25Polymorphisme 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 26Classe 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 . . . . . . . 7326.1 Classe de base super héros, interface

des fonctions d'action. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7336.2 Une dérivée pour chaque Avengers . . . . . . . . . . . . . . . . . . . . . . 7386.3 Souhait du polymorphisme et impossibilité. . . . . . . . . . . . . . . 7426.4 Virtualité, intérêt de l'interface des fonctions d'action . . . . . . 7446.5 Classe abstraite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7476.6 Version finale Avengers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 751

7. Mise en pratique classe abstraite . . . . . . . . . . . . . . . . . . . . . . . . . . . . 758


Chapitre 27Quelques comparaisons entre C et C++

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 765

2. Sur les utilisations de pointeurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7662.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7662.2 Opérateurs de pointeurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7662.3 Fonctionnement des opérateurs . . . . . . . . . . . . . . . . . . . . . . . . 7672.4 Utilisation 1 : en paramètre de fonction . . . . . . . . . . . . . . . . . . 7692.5 Utilisation 2 : mise en relation d’éléments . . . . . . . . . . . . . . . . 7722.6 Utilisation 3 : allocation dynamique. . . . . . . . . . . . . . . . . . . . . 775

3. Sur l'utilisation des paramètres et retours de fonctions . . . . . . . . . . 7833.1 Encapsulation des données C et C++ . . . . . . . . . . . . . . . . . . . 7833.2 Généralisation du code C et C++ . . . . . . . . . . . . . . . . . . . . . . 7843.3 Paramètres et retours C++ : la communication entre objets 785

4. Sur l'utilisation de l'union . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7854.1 Principe d'une union hiérarchisée en C . . . . . . . . . . . . . . . . . . . 7854.2 Traduction en C++ d'une union hiérarchisée . . . . . . . . . . . . . 7894.3 Exemple : une diversité d'ennemis avec une union en C . . . . . 7914.4 Traduction C++ avec une base et des dérivées . . . . . . . . . . . 8004.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

Gestion des erreurs1. Introduction

Le dépistage d'erreurs pendant le fonctionnement d'un programme est unpoint 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'unprogramme n'est jamais assuré. On ne peut pas prouver qu'un programme vas'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'étapesuivante, sinon il s'interrompe. Plusieurs techniques existent pour contrôlerchacune des étapes d'un programme et ce chapitre propose d'expérimenter lesplus communes. Bien entendu, la totalité des opérations réalisées dans unprogramme ne va pas être contrôlée. En général, le programmeur prend à sacharge 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.

lcroise

Tampon

© E

dit

ions

EN

I -

All r

ights

rese

rved


Langage C++

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 sitout va bien et FALSE en cas d'erreur. Dans maFonction() ci-dessous, lesinstructions 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 uneerreur, le test est vrai et l'instruction return FALSE provoque une sortie quisignale une erreur. S'il n'y a pas d'erreur, maFonction() continue de s'exécuternormalement jusqu'à l'instruction return TRUE qui indique une fin sanserreur :

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êtreconsole depuis le code. Cette fonction nécessite un certain nombre decontrôles d'erreurs.

Toutes les informations concernant une fenêtre console sont organisées etsauvegardé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;

369Gestion des erreursChapitre 16

dwSize est une structure COORD constituée de deux entiers X et Y. Ellecontient 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 relationavec le type CHAR_INFO).

srWindow correspond à la partie visible de la fenêtre.

dwMaximumWindowSize donne la taille maximum que peut prendre lafenêtre.

Pour redimensionner la fenêtre console, nous avons besoin de cinq fonctionsde la bibliothèque windows.h :

GetStdHandle() nous permet de récupérer un pointeur qui contient l'adressede la fenêtre courante.

GetLargestConsoleWindowSize() nous retourne une structure COORDavec la taille maximum que peut supporter la console.

GetConsoleScreenBufferInfo() donne toutes les informations d'unefenêtre dans une structure CONSOLE_SCREEN_BUFFER_INFO.

SetConsoleWindowInfo() permet de redimensionner la taille du rectanglepour 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'autrepart de la partie mémoire qui peut être plus grande que la partie visible, maisqui 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 partievisible 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.

© E

dit

ions

EN

I -

All r

ights

rese

rved


Langage C++

– Nous sommes obligés de traiter tous les cas possibles : largeur et hauteurpeuvent être diminuées toutes les deux, ou augmentées toutes les deux, oul'une augmentée et l'autre diminuée. Pour ce faire, nous commençons partraiter la hauteur qui peut être soit diminuée, soit augmentée et de mêmeensuite 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 etavec 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) {

// 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))

371Gestion des erreursChapitre 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;


return FALSE;

// ensuite le rectangle correspondant de la fenêtre

info.srWindow.Bottom = height - 1;


return FALSE;

}

// idem pour la largeur

if (width < info.dwSize.X) {

info.srWindow.Right = width - 1;


return FALSE;

info.dwSize.X = width;


return FALSE;

}

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

info.dwSize.X = width;


return FALSE;

info.srWindow.Right = width - 1;


return FALSE;

}

return TRUE;

}

© E

dit

ions

EN

I -

All r

ights

rese

rved


Langage C++

L'algorithme est le suivant :

– Nous récupérons un pointeur sur la fenêtre courante. En cas d'erreur, falseest 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 tailleminimum.

– Récupération des informations sur la fenêtre courante, en cas d'erreur, falseest retourné et la suite n'est pas exécutée.

– Si la hauteur demandée est inférieure à la hauteur actuelle, la hauteur de lapartie visible est diminuée et ensuite la partie mémoire est calibrée sur lanouvelle hauteur. À chaque fois, en cas d'erreur, false est retourné et la suiten'est pas exécutée.

– Si la hauteur demandée est supérieure à la hauteur actuelle, la taille de lazone mémoire est tout d'abord augmentée et ensuite la hauteur de la fenêtreest ajustée. À chaque fois, en cas d'erreur, false est retourné et la suite n'estpas 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 oupas :

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>

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;

l’héritage du c et la programmation orientée objet · pour finir, un chapitre compare le c et...

Documents