Mathieu Nebra

Matthieu Schaller
PROGRAMMEZ AVEC LE LANGAGE

C++ 2e édition

Vous aimeriez apprendre à programmer en C++ et vous cherchez un cours accessible aux
débutants ? Cet ouvrage est fait pour vous ! Conçu pour les débutants, il vous permettra de Mathieu Nebra
découvrir pas à pas le langage C++, la programmation orientée objet et bien d’autres choses !
Matthieu Schaller
Avec la participation de Ranga Gonnage

Qu’allez-vous apprendre ?

2e édition
• Qu’est-ce que la programmation ? Qu’est-ce qui
PROGRAMMEZ AVEC LE LANGAGE

C++
distingue le C++ des autres langages ?
• Installation d’un environnement de développement
et compilation de vos premiers programmes

C++
• Manipulation des variables, des fonctions,
des pointeurs, des références...

PROGRAMMEZ AVEC LE LANGAGE

• Découverte de la programmation orientée objet :
les classes, l’héritage, le polymorphisme...

2e édition
À propos des auteurs
Co-fondateur d’OpenClassrooms, Mathieu Nebra
se passionne depuis l’âge de 13 ans pour la créa-
tion de cours en ligne. Son objectif : partager
la connaissance d’une façon nouvelle, cha-
leureuse et enfin accessible à tous. Auteur de
plusieurs best-sellers, il publie régulièrement
des cours en ligne et expérimente de nouvelles
approches pédagogiques avec la communauté
de plus d’un million de membres qu’il a fédérée.
Chercheur en astrophysique et cosmologie,
Matthieu Schaller est spécialiste en simulations
numériques de galaxies sur superordinateurs.
ISBN : 978-2-416-00886-3
Code éditeur : G0100886

32 E

Couverture : Studio Eyrolles © Éditions Eyrolles

 DANS LA MÊME COLLECTION

M. Nebra. – Concevez votre site web avec PHP et MySQL.

N° 0100885, 4 e édition, 2023, 224 pages.
M. Nebra, M. Schaller. – Programmez avec le langage C++.
N°0100886, 2023, 674 pages.
V. Thuillier. – Programmez en orienté objet en PHP.
N°14472, 2 e édition, 2017, 474 pages.
J. Pardanaud, S. de la Marck. – Découvrez le langage JavaScript.
N°14399, 2017, 478 pages.
A. Bacco. – Développez votre site web avec le framework Symfony3.
N°14403, 2016, 536 pages.
M. Chavelli. – Découvrez le framework PHP Laravel.
N°14398, 2016, 336 pages.
R. De Visscher. – Découvrez le langage Swift.
N°14397, 2016, 128 pages.
M. Lorant. – Développez votre site web avec le framework Django.
N°21626, 2015, 285 pages.
E. Lalitte. – Apprenez le fonctionnement des réseaux TCP/IP.
N°21623, 2015, 300 pages.

Retrouvez nos bundles (livres papier + e-book) et livres numériques sur

http://izibook.eyrolles.com

EP2_Nebra-ProgrammezAvecLeLangageC++.indd 2 08/03/2023 17:40:21

 Mathieu Nebra & Matthieu Schaller
Avec la participation de Ranga Gonnage

PROGRAMMEZ AVEC LE LANGAGE

C++
2e édition

EP2_Nebra-ProgrammezAvecLeLangageC++.indd 3 08/03/2023 17:40:21

 ÉDITIONS EYROLLES
61, bd Saint-Germain
75240 Paris Cedex 05
www.editions-eyrolles.com

Conception couverture : Sophie Bai

Illustrations chapitres : Fan Jiyong
Illustration Figure 12.1 : Nab
Mise en pages : Sandrine Escobar

Depuis 1925, les éditions Eyrolles s’engagent en proposant des livres pour comprendre le monde,
transmettre des savoirs et cultiver ses passions !
Pour continuer à accompagner toutes les générations à venir, nous travaillons de manière respon-
sable, dans le respect de l’environnement. Nos imprimeurs sont ainsi choisis avec la plus grande
attention, afin que nos ouvrages soient imprimés sur du papier issu de forêts gérées durablement.
Nous veillons également à limiter le transport en privilégiant des imprimeurs locaux. Ainsi, 89 %
de nos impressions se font en Europe, dont plus de la moitié en France.

En application de la loi du 11 mars 1957, il est interdit de reproduire intégralement ou partiellement le présent
ouvrage, sur quelque support que ce soit, sans l’autorisation de l’Éditeur ou du Centre Français d’exploitation
du droit de copie, 20, rue des Grands Augustins, 75006 Paris.
© Groupe Eyrolles, 2017
© Editions Eyrolles, 2023 pour la présente édition
www.editions-eyrolles.com

ISBN : 978-2-416-00886-3
Sauf mention contraire, le contenu de cet ouvrage est publié sous la licence : Creative Commons BY-NC-SA 2.0
La copie de cet ouvrage est autorisée sous réserve du respect des conditions de la licence. Texte complet de la
licence disponible sur : http://creativecommons.org/licenses/by-nc-sa/2.0/fr/

EP2_Nebra-ProgrammezAvecLeLangageC++.indd 4 08/03/2023 17:40:22

 Avant-propos
De tous les langages de programmation qui existent, le C++ est certainement celui qui nour-
rit le plus de fantasmes. Est-ce parce que c’est un des langages les plus utilisés au monde ?
Ou parce que c’est un des plus puissants et des plus rapides ?
Toujours est-il que c’est le langage de prédilection de beaucoup de développeurs : il est
devenu quasi-incontournable dans la création de jeux vidéo. On l’enseigne d’ailleurs dans
la plupart des écoles d’informatique.
Alors vous y voilà vous aussi ? Vous voulez tout savoir sur le C++ mais vous n’avez jamais
programmé ? Cela peut sembler difficile au premier abord étant donné le nombre d’ouvrages,
certes intéressants mais complexes, qui existent sur le sujet. Il faut dire que le C++ est un
langage très riche qui demande de la précision et de l’organisation.
Peut-on débuter en programmation avec le C++ ? Oui, bien sûr que oui ! Nous l’avons
d’ailleurs déjà prouvé ces dernières années grâce à la version de ce cours disponible en ligne
sur OpenClassrooms. Elle a permis à de très nombreux débutants en programmation de se
former avec succès sur ce langage.
L’ouvrage que vous allez lire est la réédition du premier de la collection OpenClassrooms
rédigé par deux auteurs. Nous avons combiné nos expertises pédagogiques et techniques
pour vous proposer un cours qui soit à la fois :
• Accessible – Destiné aux débutants, il est indispensable qu’il puisse être lu sans difficulté
par tout le monde.
• Concret – Nous ne sommes pas là pour vous assommer de définitions abstraites. Nous
essaierons toujours d’aller vers du concret en prenant pour exemples des programmes que
vous connaissez déjà. Le cours est jalonné de plusieurs travaux pratiques ; l’un d’eux vous
permettra d’ailleurs de créer votre propre navigateur web.
• Attrayant, grâce aux travaux pratiques qui se veulent amusants.
Écrire ce livre était un passionnant défi que nous avons pris plaisir à relever. Nous espérons
que vous ressentirez ce même plaisir lors de votre découverte du C++.

EP2_Nebra-ProgrammezAvecLeLangageC++.indd 5 08/03/2023 17:40:22

 Programmez avec le langage C++

Qu’allez-vous apprendre en lisant ce livre ?

Le plan de ce livre a mûri pendant plusieurs années. Il se veut à la fois orienté débutants,
progressif et complet. Voici les différentes parties qui vous attendent.
1. Découverte de la programmation en C++ – Cette première partie démarre tout en
douceur en vous présentant le langage et ses domaines d’application. Nous apprendrons
ensuite à installer et à utiliser les outils nécessaires pour programmer, que ce soit sous
Windows, macOS ou Linux. Vous serez alors prêts à découvrir les fondamentaux de la
programmation en C++ et à créer vos premiers programmes.
2. Programmation Orientée Objet (POO) – Nous nous intéresserons à la programmation
orientée objet. Il s’agit d’une manière d’organiser ses programmes qui fait la force du C++.
Nous présenterons ce que sont les objets, les classes, l’héritage, le polymorphisme, etc. Ces
chapitres seront plus difficiles que ceux de la première partie, mais ils sont essentiels à la
maîtrise du langage. La difficulté sera néanmoins progressive afin de ne perdre personne
en cours de route.

Comment lire ce livre ?

Suivez l’ordre des chapitres

Lisez ce livre comme un roman. Il a été conçu de cette façon.

Contrairement à beaucoup de livres techniques qu’il est courant de parcourir en diagonale
en sautant parfois certains chapitres, il est ici très fortement recommandé de suivre l’ordre
du cours, à moins que vous ne soyez déjà un peu expérimenté.

Pratiquez en même temps

Pratiquez régulièrement. N’attendez pas d’avoir fini la lecture de ce livre pour allumer votre
ordinateur et faire vos propres essais. Lorsque vous découvrez une nouvelle commande,
essayez-la et testez de nouveaux paramètres pour voir comment elle se comporte.

Utilisez les codes web

Afin de tirer parti d’OpenClassrooms (dont ce livre est issu), ce dernier vous propose ce que
l’on appelle des « codes web » : des codes à six chiffres qu’il faut saisir sur la page suivante
pour être automatiquement redirigé vers une autre page sans avoir à en recopier l’adresse :
http://openclassrooms.com/codeweb
Un formulaire vous y invite à rentrer votre code web et vous propose un premier essai avec
123456.

VI

EP2_Nebra-ProgrammezAvecLeLangageC++.indd 6 08/03/2023 17:40:22

 Avant-propos

Ces codes web ont plusieurs intérêts :

• Ils vous redirigent vers les sites web présentés tout au long du cours, vous permettant ainsi
d’obtenir les logiciels dans leur toute dernière version.
• Ils vous proposent de télécharger les codes sources de ce livre, ce qui vous évitera d’avoir à
recopier certains programmes un peu longs.
Grâce à ce système de redirection, nous tenons à jour le livre que vous tenez entre vos mains
sans que vous ayez besoin d’acheter systématiquement chaque nouvelle édition. Si un site
web change d’adresse, nous modifierons la redirection mais le code web à utiliser restera
le même. Si un site web disparaît, nous vous redirigerons vers une page d’OpenClassrooms
expliquant ce qui s’est passé et vous proposant une alternative. Si une capture d’écran n’est
plus à jour, nous vous indiquerons ce qui a changé et comment procéder.
En clair, c’est un moyen de nous assurer de la pérennité de cet ouvrage sans que vous ayez
à faire quoi que ce soit.

Ce livre est issu d’OpenClassrooms

Cet ouvrage reprend le cours sur C++ d’OpenClassrooms dans une édition revue et corrigée,
augmentée de nouveaux chapitres plus avancés1 et de notes de bas de page.
Il reprend les éléments qui ont fait le succès des cours du site, à savoir leur approche progres-
sive et pédagogique, leur ton décontracté, ainsi que les nombreux schémas aidant à mieux
comprendre le fonctionnement de la programmation en C++.
Bien que ce cours soit rédigé à quatre mains, nous nous exprimons à la première personne
du singulier. Cela renforce la proximité entre le lecteur et l’auteur2. Imaginez tout simplement
que vous êtes seul avec votre professeur dans une même pièce.

Remerciements

Nous tenons à remercier toutes les personnes qui nous ont aidés et soutenus dans la réali-
sation de ce livre.
Mathieu Nebra
Je souhaite remercier :
• mes parents, qui me font confiance et continuent de suivre attentivement mes projets ;
• Élodie, qui est toujours là pour me donner la dose de courage dont j’ai besoin ;
• Pierre Dubuc, qui s’est mis en quatre pour que ce livre soit publié dans les meilleures
conditions possibles ;

1 Vous y découvrirez notamment comment utiliser des itérateurs sur les flux, les chaînes de caractères, les
tableaux... et vous verrez que le C++ permet de faire du calcul scientifique.
2 Il faut noter que nous nous sommes répartis la rédaction des chapitres. Ainsi, nous nous exprimons en
« je » à tour de rôle.

VII

EP2_Nebra-ProgrammezAvecLeLangageC++.indd 7 08/03/2023 17:40:22

 Programmez avec le langage C++

• notre infographiste, Fan Jiyong, qui a réalisé la couverture du premier tirage de ce livre, ainsi
que des illustrations des chapitres ;
• Matthieu Schaller, pour ses conseils avisés qui ont permis à ce cours – dont il est devenu
co-auteur – de gagner en rigueur et en précision ;
• l’équipe d’OpenClassrooms, qui fait un travail formidable pour améliorer le site ;
• et tous nos visiteurs qui nous font confiance : merci, merci, merci !
Matthieu Schaller
Je souhaite remercier :
• mes parents et ma famille, pour leur soutien indéfectible quel que soit le projet dans lequel
je m’embarque ;
• Mathieu Nebra, pour sa confiance, son enthousiasme, ses leçons de pédagogie et son temps
passé à corriger mon orthographe ;
• l’équipe d’OpenClassrooms, pour son travail et son aide lors de la relecture des chapitres ;
• Luc Hermitte pour ses précieux conseils et son immense expérience du C++ ;
• Jean-Cédric Chappelier, mon professeur d’informatique, pour son enseignement et la
rigueur qu’il a su apporter à mon bagage technique.

VIII

EP2_Nebra-ProgrammezAvecLeLangageC++.indd 8 08/03/2023 17:40:22

 Table des matières
Première partie – Découverte de la programmation en C++ 1

1 Qu’est-ce que le C++ ? 3

Les programmes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Les langages de programmation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Le C++ face aux autres langages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Langage de haut ou de bas niveau ?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Petit aperçu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
La petite histoire du C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
De l’Algol au C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Le concepteur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2 Les logiciels nécessaires pour programmer 13

Les outils nécessaires au programmeur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Les projets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Choisissez votre IDE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Code::Blocks (Windows, macOS, Linux) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Créer un nouveau projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Visual Studio (Windows seulement) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Installation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Créer un nouveau projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Xcode (macOS seulement) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

EP2_Nebra-ProgrammezAvecLeLangageC++.indd 9 08/03/2023 17:40:23

 Programmez avec le langage C++

Installation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Créer un nouveau projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3 Votre premier programme 27

Le monde merveilleux de la console. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Les programmes graphiques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Les programmes en console. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Notre première cible : les programmes en console . . . . . . . . . . . . . . . . . . . . . . . 29
Création et lancement d’un premier projet. . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Création d’un projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Lancement du programme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Explications sur ce premier code source. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
La ligne include. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
La ligne using namespace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
La ligne int main(). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
La ligne cout. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
La ligne return. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Commentez vos programmes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Les différents types de commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Commentons notre code source. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Mettez votre code en forme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

4 Utiliser la mémoire 39
Qu’est-ce qu’une variable ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Les noms de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Les types de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Déclarer une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Le cas des chaînes de caractères (strings). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Une astuce pour gagner de la place . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Déclarer sans initialiser. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Afficher la valeur d’une variable. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Les références. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

5 Une vraie calculatrice 51

Demander des informations à l’utilisateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Lecture depuis la console. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Une astuce pour les chevrons. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

EP2_Nebra-ProgrammezAvecLeLangageC++.indd 10 08/03/2023 17:40:23

 Table des matières

D’autres variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Le problème des espaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
Demander d’abord la valeur de pi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Modifier des variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Changer le contenu d’une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Une vraie calculatrice de base. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
Les constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Déclarer une constante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Un premier exercice. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Les raccourcis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
L’incrémentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
La décrémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Les autres opérations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Encore plus de maths !. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
L’en-tête cmath. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Racine carrée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Autres fonctions présentes dans cmath. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Le cas de la fonction puissance. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

6 Les structures de contrôle 69

Les conditions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
La condition if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
La condition switch. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Booléens et combinaisons de conditions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Les booléens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Combiner des conditions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Les boucles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
La boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
La boucle do...while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
La boucle for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

7 Découper son programme en fonctions 83

Créer et utiliser une fonction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Présentation des fonctions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Définir une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Créer une fonction toute simple. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Appeler une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Une fonction qui prend plusieurs paramètres. . . . . . . . . . . . . . . . . . . . . . . . . . . 88

XI

EP2_Nebra-ProgrammezAvecLeLangageC++.indd 11 08/03/2023 17:40:23

 Programmez avec le langage C++

Une fonction sans arguments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

Une fonction qui ne renvoie rien. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Quelques exemples d’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Calculer le carré d’un nombre. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Des fonctions différentes avec des variables portant le même nom. . . . . . . . . . . . 91
Une fonction à deux arguments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Notions avancées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Passage par valeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Passage par référence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Passage par référence constante. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Utiliser plusieurs fichiers sources. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Les fichiers nécessaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Déclarer la fonction dans les fichiers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Commenter son code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
Des valeurs par défaut pour les arguments. . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
Les valeurs par défaut. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
Cas particuliers, attention danger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

8 Les tableaux 109

Les tableaux statiques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Un exemple d’utilisation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Déclarer un tableau statique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
Accéder aux éléments d’un tableau. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
Parcourir un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Un petit exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Les tableaux et les fonctions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Les tableaux dynamiques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
Déclarer un tableau dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
Accéder aux éléments d’un tableau. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
Changer la taille. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
Exercice : calculer une moyenne. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
Les tableaux dynamiques et les fonctions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
Les tableaux multidimensionnels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Déclarer un tableau multidimensionnel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
Accéder aux éléments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
Aller plus loin. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
Les chaînes utilisées comme des tableaux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
Accéder aux caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

XII

EP2_Nebra-ProgrammezAvecLeLangageC++.indd 12 08/03/2023 17:40:23

 Table des matières

9 Lire et modifier des fichiers 127

Écrire dans un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
L’en-tête fstream . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Ouvrir un fichier en écriture. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Écrire dans un flux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
Les différents modes d’ouverture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
Lire un fichier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
Ouvrir un fichier en lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
Lire le contenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
Lire un fichier en entier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
Quelques astuces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
Fermer prématurément un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
Le curseur dans le fichier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Connaître sa position. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
Se déplacer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
Connaître la taille d’un fichier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

10 TP : Le mot mystère 139

Préparatifs et conseils. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
Principe du jeu « Le mot mystère ». . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
Quelques conseils pour bien démarrer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
Repérer les étapes du programme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
Créer un canevas de code avec les étapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
Un peu d’aide pour mélanger les lettres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Correction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Le code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Des explications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
Aller plus loin. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146

11 Les pointeurs 147

Une question d’adresse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
Afficher l’adresse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
Les pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
Déclarer un pointeur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
Stocker une adresse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
Afficher l’adresse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
Accéder à la valeur pointée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
Récapitulatif de la notation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
L’allocation dynamique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
La gestion automatique de la mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154

XIII

EP2_Nebra-ProgrammezAvecLeLangageC++.indd 13 08/03/2023 17:40:23

 Programmez avec le langage C++

Allouer un espace mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154

Libérer la mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
Un exemple complet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
Quand utiliser des pointeurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
Partager une variable. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
Choisir parmi plusieurs éléments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160

Deuxième partie – La Programmation Orientée Objet 161

12 La vérité sur les chaînes enfin dévoilée 163

Des objets... pour quoi faire ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Comprendre le fonctionnement du type string . . . . . . . . . . . . . . . . . . . . . . 164
Pour un ordinateur, les lettres n’existent pas. . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Les textes sont des tableaux de caractères. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
Créer et utiliser des objets string . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
Créer un objet string. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
Concaténation de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
Comparaison de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
Opérations sur les chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
Attributs et méthodes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
Quelques méthodes utiles du type string. . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172

13 Les classes (partie 1/2) 173

Qu’est-ce qu’une classe ?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
Quelle classe créer ?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
Définition d’une classe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
Ajout de méthodes et d’attributs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
Les attributs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
Les méthodes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
Droits d’accès et encapsulation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
Les droits d’accès . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
L’encapsulation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
Séparer prototypes et définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
Personnage.hpp. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
Personnage.cpp. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
main.cpp. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186

XIV

EP2_Nebra-ProgrammezAvecLeLangageC++.indd 14 08/03/2023 17:40:23

 Table des matières

14 Les classes (partie 2/2) 187

Constructeur et destructeur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
Le constructeur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
Le destructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
Les méthodes constantes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
Associer des classes entre elles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
La classe Arme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
Adapter la classe Personnage pour utiliser la classe Arme. . . . . . . . . . . . . . . . . 197
Afficher l’état des personnages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
Ajout du prototype. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
Implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
Appel de afficherEtat dans le main() . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
Résumé de la structure du code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203

15 La surcharge d’opérateurs 205

Petits préparatifs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
Principe de la surcharge d’opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
La classe Duree pour nos exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
Les opérateurs de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
L’opérateur == . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
L’opérateur != . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
L’opérateur < . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
Les autres opérateurs de comparaison. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
Les opérateurs arithmétiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
L’opérateur d’addition +. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
Les autres opérateurs arithmétiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
Les opérateurs de flux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
Définir ses propres opérateurs pour cout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
Implémentation d’operator<<. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
Afficher des objets Duree dans le main() . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223

16 TP : La POO en pratique 225

Préparatifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
Description de la classe Fraction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
Créer un nouveau projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
Le code de base des fichiers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
Construction de la classe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
Choix des attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228

XV

EP2_Nebra-ProgrammezAvecLeLangageC++.indd 15 08/03/2023 17:40:24

 Programmez avec le langage C++

Les constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228

Les opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
Correction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
Les constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
Afficher une fraction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
L’opérateur de multiplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
L’opérateur de comparaison. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
Aller plus loin. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231

17 Classes et pointeurs 233

Pointer une classe vers une autre classe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
Gérer l’allocation dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
Allouer de la mémoire pour l’objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
Désallouer de la mémoire pour l’objet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
Adapter les méthodes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
Le pointeur this. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
Le constructeur de copie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
Le problème. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
Créer le constructeur de copie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
Terminer le constructeur de copie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
L’opérateur d’affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246

18 L’héritage 247
Exemple d’héritage simple. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
Comment reconnaître un héritage ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
Notre exemple : la classe Personnage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
La classe Guerrier hérite de la classe Personnage. . . . . . . . . . . . . . . . . . . . . 249
La classe Magicien hérite aussi de Personnage. . . . . . . . . . . . . . . . . . . . . . . 251
La dérivation de type. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
Héritage et constructeurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
Appeler le constructeur de la classe mère . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
Transmission de paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
La portée protected. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
Le masquage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
Une fonction de la classe mère. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
La fonction est héritée dans les classes filles. . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
Le masquage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
Le démasquage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261

XVI

EP2_Nebra-ProgrammezAvecLeLangageC++.indd 16 08/03/2023 17:40:24

 Table des matières

19 Le polymorphisme 263
La résolution des liens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264
La résolution statique des liens. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
La résolution dynamique des liens. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
Les méthodes spéciales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
Le cas des constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
Le cas du destructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
Le code amélioré. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
Les collections hétérogènes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
Le retour des pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
Utiliser la collection. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
Les fonctions virtuelles pures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
Le problème des roues. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
Les classes abstraites. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
À vous de jouer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

20 Éléments statiques et amitié 279

Les méthodes statiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
Créer une méthode statique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
Les attributs statiques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
Créer un attribut statique dans une classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
L’amitié. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
Qu’est-ce que l’amitié ?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
Retour sur la classe Duree. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
Déclarer une fonction amie d’une classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
L’amitié et la responsabilité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286

Index 287

XVII

EP2_Nebra-ProgrammezAvecLeLangageC++.indd 17 08/03/2023 17:40:24

EP2_Nebra-ProgrammezAvecLeLangageC++.indd 18 08/03/2023 17:40:24