Programmer

LA PROGRAMMATION POUR. . .
2
les élèves ingénieurs
2
. . . ou les collégiens
2
débutants
2
. . . ou confirmés
Cours de l’École des Ponts ParisTech - 2020/2021

Renaud Keriven et Pascal Monasse
IMAGINE - École des Ponts ParisTech
[email protected]
Version électronique et programmes :
http://imagine.enpc.fr/~monasse/Info/
"Ne traitez pas vos ordinateurs comme des êtres vivants. . .
Ils n’aiment pas ça !"
— "Cet ordinateur ne fait pas du tout ce que je veux !"

— "Exact. . . Il fait ce que tu lui demandes de faire !"
TABLE DES MATIÈRES TABLE DES MATIÈRES
Table des matières
1 Préambule 7
1.1 Pourquoi savoir programmer ? . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2 Comment apprendre ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2.1 Choix du langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2.2 Choix de l’environnement . . . . . . . . . . . . . . . . . . . . . . . 11
1.2.3 Principes et conseils . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2 Bonjour, Monde ! 15
2.1 L’ordinateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.1.1 Le micro-processeur . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.1.2 La mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.1.3 Autres Composants . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2 Système d’exploitation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.3 La Compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.4 L’environnement de programmation . . . . . . . . . . . . . . . . . . . . . 25
2.4.1 Noms de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.4.2 Debuggeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.5 Le minimum indispensable . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.5.1 Pour comprendre le TP . . . . . . . . . . . . . . . . . . . . . . . . 26
2.5.2 Un peu plus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.5.3 Le debuggeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.5.4 TP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3 Premiers programmes 31
3.1 Tout dans le main() ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.1.1 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.1.2 Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.1.3 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.1.4 Récréations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.2 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.2.1 Retour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.2.2 Paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.2.3 Passage par référence . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.2.4 Portée, Déclaration, Définition . . . . . . . . . . . . . . . . . . . . 48
3.2.5 Variables locales et globales . . . . . . . . . . . . . . . . . . . . . . 49
3.2.6 Surcharge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.3 TP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.4 Fiche de référence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4 Les tableaux 55
4.1 Premiers tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.2 Initialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.3 Spécificités des tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.3.1 Tableaux et fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.3.2 Affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
4.4 Récréations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.4.1 Multi-balles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.4.2 Avec des chocs ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.4.3 Mélanger les lettres . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.5 TP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5 Les structures 71
5.1 Révisions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
5.1.1 Erreurs classiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
5.1.2 Erreurs originales . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.1.3 Conseils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
5.2 Les structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
5.2.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
5.2.2 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
5.3 Récréation : TP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
6 Plusieurs fichiers ! 79
6.1 Fichiers séparés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
6.1.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
6.1.2 Avantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
6.1.3 Utilisation dans un autre projet . . . . . . . . . . . . . . . . . . . . 82
6.1.4 Fichiers d’en-têtes . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
6.1.5 À ne pas faire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
6.1.6 Implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
6.1.7 Inclusions mutuelles . . . . . . . . . . . . . . . . . . . . . . . . . . 86
6.1.8 Chemin d’inclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
6.2 Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
6.3 Récréation : TP suite et fin . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
7 La mémoire 93
7.1 L’appel d’une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
7.1.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
7.1.2 Pile des appels et débuggeur . . . . . . . . . . . . . . . . . . . . . 95
7.2 Variables Locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
7.2.1 Paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
7.2.2 La pile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
7.3 Fonctions récursives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
7.3.1 Pourquoi ça marche ? . . . . . . . . . . . . . . . . . . . . . . . . . . 98
7.3.2 Efficacité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
2
7.4 Le tas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

7.4.1 Limites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
7.4.2 Tableaux de taille variable . . . . . . . . . . . . . . . . . . . . . . . 101
7.4.3 Essai d’explication . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
7.5 L’optimiseur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
7.6 Assertions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
7.7 Tableaux bidimensionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
7.8 Examens sur machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
8 Allocation dynamique 107

8.1 Tableaux bidimensionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
8.1.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
8.1.2 Limitations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
8.1.3 Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
8.2 Allocation dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
8.2.1 Pourquoi ça marche ? . . . . . . . . . . . . . . . . . . . . . . . . . . 110
8.2.2 Erreurs classiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
8.2.3 Conséquences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
8.3 Structures et allocation dynamique . . . . . . . . . . . . . . . . . . . . . . 113
8.4 Boucles et continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
8.5 TP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
9 Premiers objets 121

9.1 Philosophie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
9.2 Exemple simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
9.3 Visibilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
9.4 Exemple des matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
9.5 Cas des opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
9.6 Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
9.7 Protection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
9.7.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
9.7.2 Structures vs Classes . . . . . . . . . . . . . . . . . . . . . . . . . . 131
9.7.3 Accesseurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
9.8 TP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
10 Constructeurs et Destructeurs 137

10.1 Le problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
10.2 La solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
10.3 Cas général . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
10.3.1 Constructeur vide . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
10.3.2 Plusieurs constructeurs . . . . . . . . . . . . . . . . . . . . . . . . 140
10.3.3 Tableaux d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
10.4 Objets temporaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
10.5 TP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
10.6 Références Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
3
10.6.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

10.6.2 Méthodes constantes . . . . . . . . . . . . . . . . . . . . . . . . . . 144
10.7 Destructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
10.8 Destructeurs et tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
10.9 Constructeur de copie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
10.10Affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
10.11Objets avec allocation dynamique . . . . . . . . . . . . . . . . . . . . . . . 150
10.11.1 Construction et destruction . . . . . . . . . . . . . . . . . . . . . . 150
10.11.2 Problèmes ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
10.11.3 Solution ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
10.12Fiche de référence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
11 Chaînes de caractères, fichiers 159

11.1 Chaînes de caratères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
11.2 Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
11.2.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
11.2.2 Chaînes et fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
11.2.3 Objets et fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
11.3 Valeurs par défaut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
11.3.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
11.3.2 Utilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
11.3.3 Erreurs fréquentes . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
11.4 Accesseurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
11.4.1 Référence comme type de retour . . . . . . . . . . . . . . . . . . . 165
11.4.2 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
11.4.3 operator() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
11.4.4 Surcharge et méthode constante . . . . . . . . . . . . . . . . . . . 167
11.4.5 "inline" . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
11.5 Assertions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
11.6 Types énumérés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
12 Fonctions et classes paramétrées (templates) 175

12.1 template . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
12.1.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
12.1.2 template et fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . 176
12.1.3 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
12.1.4 STL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
12.2 Opérateurs binaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
12.3 Valeur conditionnelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
12.4 Boucles et break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
12.5 Variables statiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
12.6 const et tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
4
A Travaux Pratiques 193

A.1 L’environnement de programmation . . . . . . . . . . . . . . . . . . . . . 193
A.1.1 Bonjour, Monde ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
A.1.2 Premières erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
A.1.3 Debugger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
A.1.4 S’il reste du temps . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
A.1.5 Installer Imagine++ chez soi . . . . . . . . . . . . . . . . . . . . . . 198
A.2 Variables, boucles, conditions, fonctions . . . . . . . . . . . . . . . . . . . 199
A.2.1 Premier programme avec fonctions . . . . . . . . . . . . . . . . . 199
A.2.2 Premier programme graphique avec Imagine++ . . . . . . . . . . 199
A.2.3 Jeu de Tennis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
A.3 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
A.3.1 Mastermind Texte . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
A.3.2 Mastermind Graphique . . . . . . . . . . . . . . . . . . . . . . . . 205
A.4 Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
A.4.1 Etapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
A.4.2 Aide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
A.4.3 Théorie physique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
A.5 Fichiers séparés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
A.5.1 Fonctions outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
A.5.2 Vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
A.5.3 Balle à part . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
A.5.4 Retour à la physique . . . . . . . . . . . . . . . . . . . . . . . . . . 213
A.6 Images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
A.6.1 Allocation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
A.6.2 Tableaux statiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
A.6.3 Tableaux dynamiques . . . . . . . . . . . . . . . . . . . . . . . . . 217
A.6.4 Charger un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
A.6.5 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
A.6.6 Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
A.6.7 Suite et fin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
A.7 Premiers objets et dessins de fractales . . . . . . . . . . . . . . . . . . . . 220
A.7.1 Le triangle de Sierpinski . . . . . . . . . . . . . . . . . . . . . . . . 220
A.7.2 Une classe plutôt qu’une structure . . . . . . . . . . . . . . . . . . 221
A.7.3 Changer d’implémentation . . . . . . . . . . . . . . . . . . . . . . 221
A.7.4 Le flocon de neige . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
A.8 Tron . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
A.8.1 Serpent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
A.8.2 Tron . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
A.8.3 Graphismes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
A.8.4 Peaufiner le code . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
B Imagine++ 227
B.1 Common . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
B.2 Graphics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
B.3 Images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
B.4 LinAlg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
B.5 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
5
C Compilateur, CMake, Linker, Qt. . . Au secours ! 231

C.1 Compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
C.1.1 Compilateur et linker . . . . . . . . . . . . . . . . . . . . . . . . . 231
C.2 En ligne de commande . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
C.3 Make et CMake . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
C.4 Utilisation d’un IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
D Fiche de référence finale 237
6
1. Préambule
Chapitre 1
Préambule
Note : Ce premier chapitre maladroit correspond à l’état d’esprit dans lequel ce

cours a débuté en 2003, dans une période où l’Informatique avait mauvaise presse à
l’École des Ponts. Nous le maintenons ici en tant que témoin de ce qu’il fallait faire alors
pour amener les élèves à ne pas négliger l’Informatique. Si l’on ignore la naïveté de
cette première rédaction (et le fait que Star Wars n’est plus autant à la mode !), l’analyse
et les conseils qui suivent restent d’actualité.
(Ce premier chapitre tente surtout de motiver les élèves ingénieurs dans leur apprentissage
de la programmation. Les enfants qui se trouveraient ici pour apprendre à programmer sont
sûrement déjà motivés et peuvent sauter au chapitre suivant ! Profitons-en pour tenir des propos
qui ne les concernent pas. . . )
— Le Maître Programmeur 1 : "Rassure-toi ! Les ordinateurs sont stupides ! Program-

mer est donc facile."
— L’Apprenti Programmeur 2 : "Maître, les ordinateurs ne sont certes que des ma-
chines et les dominer devrait être à ma portée. Et pourtant. . . Leur manque d’in-
telligence fait justement qu’il m’est pénible d’en faire ce que je veux. Programmer
exige de la précision et la moindre erreur est sanctionnée par un message incom-
préhensible, un bug 3 ou même un crash de la machine. Pourquoi doit-on être
aussi. . . précis ?" Programmer rend maniaque ! D’ailleurs, les informaticiens sont tous
maniaques. Et je n’ai pas envie de devenir comme ça. . .
1. Permettez ce terme ouvertement Lucasien. Il semble plus approprié que l’habituel Gourou souvent
utilisé pour décrire l’expert informaticien. Nous parlons bien ici d’un savoir-faire à transmettre de Maître
à Apprenti et non d’une secte. . .
2. Le jeune Padawan, donc, pour ceux qui connaissent. . .
3. Je n’aurai aucun remord dans ce polycopié à utiliser les termes habituels des informaticiens. . . en
essayant évidemment de ne pas oublier de les expliquer au passage. Anglicismes souvent incompré-
hensibles, ils constituent en réalité un argot propre au métier d’informaticien, argot que doit bien évi-
demment accepter et faire sien l’Apprenti sous peine de ne rien comprendre au discours de ses collègues
d’une part, et d’employer des adaptations françaises ridicules ou peu usitées d’autre part. Naviguer sur
la toile, envoyer un courriel ou avoir un bogue commencent peut-être à devenir des expressions com-
préhensibles. Mais demandez-donc à votre voisin s’il reçoit beaucoup de pourriels (terme proposé pour
traduire "Spams") !
1. Préambule
— M.P. : "La précision est indispensable pour communiquer avec une machine. C’est
à l’Homme de s’adapter. Tu dois faire un effort. En contre-partie tu deviendras
son maître. Réjouis-toi. Bientôt, tu pourras créer ces êtres obéissants que sont les
programmes."
— A.P. : "Bien, Maître. . . " Quel vieux fou ! Pour un peu, il se prendrait pour Dieu. La
vérité, c’est qu’il parle aux machines parce qu’il ne sait pas parler aux hommes. Il comble
avec ses ordinateurs son manque de contact humain. L’informaticien type. . . Il ne lui
manque plus que des grosses lunettes et les cheveux gras 4 . "Maître, je ne suis pas sûr
d’en avoir envie. Je n’y arriverai pas. Ne le prenez pas mal, mais je crois être
davantage doué pour les Mathématiques ! Et puis, à quoi savoir programmer me
servira-t-il ?"
— M.P. : "Les vrais problèmes qui se poseront à toi, tu ne pourras toujours les ré-
soudre par les Mathématiques. Savoir programmer, tu devras !"
— A.P. : "J’essaierai. . . " Je me demande s’il a vraiment raison ! Je suis sûr qu’il doit être nul
en Maths. Voilà la vérité !
— ...
Oublions là ce dialogue aussi caricatural que maladroit. Il montre pourtant claire-

ment la situation. Résumons :
— Pour celui qui sait, programmer :
— est un jeu d’enfant.
— est indispensable.
— est une activité créatrice et épanouissante.
— Pour celui qui apprend, programmer :
— est difficile.
— ne sert à rien.
— est une activité ingrate qui favorise le renfermement 5 sur soi-même.
Dans le cas où l’élève est ingénieur, nous pouvons compléter le tableau :
— Pour le professeur, apprendre à programmer :
— devrait être simple et rapide pour un élève ingénieur.
— est plus utile qu’apprendre davantage de Mathématiques.
— Pour l’élève, programmer :
— est un travail de "technicien 6 " qu’il n’aura jamais à faire lui-même.
— n’est pas aussi noble que les Mathématiques, bref, n’est pas digne de lui.
En fait, les torts sont partagés :
— Le professeur :
4. Toute ressemblance avec des personnages réels ou imaginaires, etc.
5. Utiliser un ordinateur pour programmer a tout aussi mauvaise presse que de jouer aux jeux vidéo.
Programmer est pourtant souvent un travail d’équipe.
6. avec tout le sens péjoratif que ce terme peut avoir pour lui.
8
1. Préambule
— ne réalise pas que ses élèves ont un niveau avancé en maths parce qu’ils en
font depuis plus de dix ans, et qu’il leur faudra du temps pour apprendre ne
serait-ce que les bases de la programmation. Du temps. . . et de la pratique,
car, si programmer est effectivement simple en regard de ce que ses élèves
savent faire en maths, il nécessite une tournure d’esprit complètement diffé-
rente et beaucoup de travail personnel devant la machine.
— oublie qu’il a le plus souvent appris seul quand il était plus jeune, en pro-
grammant des choses simples et ludiques 7 . Il devrait donc faire venir ses
élèves à la programmation par le côté ludique, et non avec les mêmes sem-
piternels exemples 8 .
— L’élève :
— ne se rend pas compte que savoir programmer lui sera utile. Il s’agit pour-
tant d’une base qui se retrouve dans tous les langages et même dans la plu-
part des logiciels modernes 9 . Et puis, considéré comme "le jeune" donc le
moins "allergique" aux ordinateurs, il se verra vraisemblablement confier à
son premier poste la réalisation de quelques petits programmes en plus de
ses attributions normales.
— s’arrange un peu trop facilement d’un mépris de bon ton pour la program-
mation. Il lui est plus aisé d’apprendre une n-ième branche des mathéma-
tiques que de faire l’effort d’acquérir par la pratique une nouvelle tournure
d’esprit.
On l’aura compris, il est à la fois facile et difficile d’apprendre à programmer. Pour
l’ingénieur, cela demandera de la motivation et un peu d’effort : essentiellement de
mettre ses maths de côté et de retrouver le goût des choses basiques. Pour un collé-
gien, motivation et goût de l’effort seront au rendez-vous. Il lui restera malgré tout à
acquérir quelques bases d’arithmétique et de géométrie. Comme annoncé par le titre
de ce cours, collégien et ingénieur en sont au même point pour l’apprentissage de la
programmation. De plus, et c’est un phénomène relativement nouveau, il en est de
même pour le débutant et le "geek 10 ". Expliquons-nous : le passionné d’informatique
a aujourd’hui tellement de choses à faire avec son ordinateur qu’il sera en général in-
collable sur les jeux, internet, les logiciels graphiques ou musicaux, l’installation ou
la configuration de son système, l’achat du dernier gadget USB à la mode, etc. mais
qu’en contrepartie il sera mauvais programmeur. Il y a quelques années, il y avait peu
à faire avec son ordinateur sinon programmer. Programmer pour combler le manque
de possibilités de l’ordinateur. Aujourd’hui, faire le tour de toutes les possibilités d’un
ordinateur est une occupation à plein temps ! Ainsi, le "fana info" passe-t-il sa journée à
se tenir au courant des nouveaux logiciels 11 et en oublie qu’il pourrait lui aussi en créer.
7. C’est une erreur fréquente de croire qu’il intéressera ses élèves en leur faisant faire des pro-
grammes centrés sur les mathématiques ou le calcul scientifique. De tels programmes leur seront peut-
être utiles plus tard, mais ne sont pas forcément motivants. L’algèbre linéaire ou l’analyse numérique
sont des domaines passionnants à étudier. . . mais certainement pas à programmer. Il faut admettre sans
complexe que programmer un flipper, un master-mind ou un labyrinthe 3D est tout aussi formateur et
plus motivant qu’inverser une matrice creuse.
8. La liste est longue, mais tellement vraie : quel cours de programmation ne rabâche pas les célèbres
"factorielle", "suites de Fibonacci", "Quick Sort", etc ?
9. Savoir programmer ne sert pas seulement à faire du C++ ou du Java, ni même du Scilab, du Matlab
ou du Maple : une utilisation avancée d’Excel ou du Word demande parfois de la programmation !
10. Une récompense à qui me trouve un substitut satisfaisant à cette expression consacrée.
11. Sans même d’ailleurs avoir le temps d’en creuser convenablement un seul !
9
1.1. Pourquoi savoir programmer ? 1. Préambule
En conclusion, collégiens ou ingénieurs, débutants ou passionnés, tous les élèves sont

à égalité. C’est donc sans complexe que l’ingénieur pourra apprendre à programmer
en même temps que le fils de la voisine.
1.1 Pourquoi savoir programmer ?

Nous venons partiellement de le dire. Résumons et complétons :
1. C’est la base. Apprendre un langage précis n’est pas du temps perdu car les
mêmes concepts se retrouvent dans la plupart des langages. De plus, les logiciels
courants eux-mêmes peuvent se programmer.
2. Il est fréquent qu’un stage ou qu’une embauche en premier poste comporte un
peu de programmation, même, et peut-être surtout, dans les milieux où peu de
gens programment.
3. Savoir programmer, c’est mieux connaître le matériel et les logiciels, ce qui est
possible techniquement et ce qui ne l’est pas. Même à un poste non technique,
c’est important pour prendre les bonnes décisions.
1.2 Comment apprendre ?

1.2.1 Choix du langage
Il faut d’abord choisir un langage de programmation. Un ingénieur pourrait évi-
demment être tenté d’apprendre à programmer en Maple, Matlab, Scilab ou autre. Il
faut qu’il comprenne qu’il s’agit là d’outils spécialisés pour mathématicien ou ingé-
nieur qui lui seront utiles et qui, certes, se programment, mais pas à proprement parler
de langages généralistes complets. Sans argumenter sur les défauts respectifs des lan-
gages qui en font partie, il nous semble évident qu’il ne s’agit pas du bon choix pour
l’apprentissage de la programmation.
En pratique, le choix actuel se fait souvent entre C++ et Java. Bien que Java ait été
conçu, entre autres, dans un souci de simplification du C++ 12 , nous préférerons C++
pour des raisons pédagogiques :
1. C++ est plus complexe dans son ensemble mais n’en connaître que les bases est
déjà bien suffisant. Nous ne verrons donc dans ce cours qu’un sous ensemble du
C++, suffisant en pratique.
2. Plus complet, C++ permet une programmation de haut niveau mais aussi une
programmation simple, adaptée au débutant 13 . C++ permet également une pro-
grammation proche de la machine, ce qui est important pour le spécialiste mais
aussi pour le débutant, car seule une bonne compréhension de la machine aboutit
à une programmation convenable et efficace 14 .
3. C++ est souvent incontournable dans certains milieux, par exemple en finance.
12. Nous ne réduisons évidemment pas Java à un sous ensemble de C++. Il lui est supérieur sur
certains aspects mais il est d’expressivité plus réduite.
13. Java force un cadre de programmation objet, déroutant pour le débutant.
14. Ne pas comprendre ce que la machine doit faire pour exécuter un programme, conduit à des pro-
grammes inconsidérément gourmands en temps ou mémoire.
10
1. Préambule 1.2. Comment apprendre ?
4. Enfin, certains aspects pratiques et pourtant simples de C++ ont disparu dans
Java 15 .
Depuis quelques années, un langage qui s’impose de plus en plus est le Python. La
raison est qu’il est portable, puissant et facile d’accès. Cependant, il présente des in-
convénients. Il est en constante évolution, non standardisé, et la compatibilité entre les
versions n’est pas garantie 16 . De plus, les structures de données de Python, certes très
utiles, cachent la complexité qu’il y a derrière du point de vue de la gestion mémoire,
et il est important pour un ingénieur d’être conscient de ce qui se passe en coulisse.
Encore une fois, répétons que le choix du langage n’est pas le plus important et que
l’essentiel est d’apprendre à programmer.
1.2.2 Choix de l’environnement

Windows et Linux ont leurs partisans, souvent farouchement opposés, à tel point
que certains n’admettent pas qu’il est possible d’être partisan des deux systèmes à la
fois. Conscients des avantages et des inconvénients de chacun des deux systèmes, nous
n’en prônons aucun en particulier 17 . Ceci dit, pour des raisons pédagogiques, nous
pensons qu’un environnement de programmation intégré, c’est à dire un logiciel unique
permettant de programmer, est préférable à l’utilisation de multiples logiciels (éditeur,
compilateur, debuggeur, etc.). C’est vrai pour le programmeur confirmé, qui trouve
en général dans cet environnement des outils puissants, mais c’est encore plus crucial
pour le débutant. Un environnement de programmation, c’est :
— Toutes les étapes de la programmation regroupées en un seul outil de façon co-
hérente.
— Editer ses fichiers, les transformer en programme, passer en revue ses erreurs,
détecter les bugs, parcourir la documentation, etc. tout cela avec un seul outil
ergonomique.
Différents environnements de développement peuvent être choisis. L’environnement
de référence sous Windows est celui de Microsoft, Visual Studio, qui existe en ver-
sion gratuite, Express. C’est probablement l’un des meilleurs logiciels issus de la firme
de Redmond 18 . Sous Linux, conseillons KDevelop et sous Mac XCode. L’inconvénient
est qu’ils n’ont pas par défaut les mêmes raccourcis clavier que Visual. Certains fonc-
tionnent sous toutes les plates-formes (Linux, Windows, Mac), en particulier QtCrea-
tor. L’avantage de ce dernier est qu’il utilise par défaut les mêmes raccourcis clavier
que Visual Studio, mais qu’il comprend en plus le format CMake (dont nous reparle-
rons dans les TP). Son interface est fortement inspirée de KDevelop et XCode. Comme
pour le choix du langage, le choix de l’environnement n’est pas limitant et en connaître
un permet de s’adapter facilement à n’importe quel autre.
Le reste de ce poly est orienté vers QtCreator. Notons qu’il est facile d’installation
sur toutes les plates-formes. Sous Windows et Mac, il vient avec les librairies Qt, dont
de toutes facons nous avons besoin pour utiliser Imagine++, que nous utiliserons
pour tout ce qui est interface graphique. De plus, sous Windows nous n’avons pas de
15. Les opérateurs par exemple.

16. Ainsi l’opération 3/4 donnera 0 en Python 2 (quotient de division euclidienne) et 0.75 en Java 3.
17. L’idéal est en fait d’avoir les deux "sous la main".
18. Le seul utilisable, diront les mauvaises langues. . .
11
1.2. Comment apprendre ? 1. Préambule
compilateur C++ par défaut 19 , mais en installant la version de Qt pour MinGW on bé-
néficie justement du compilateur MinGW 20 . Un autre compilateur pour Windows est
celui de Microsoft qui vient avec VisualStudio, qui est certes gratuit mais ne l’installez
que si ça ne vous dérange pas de donner à Microsoft des informations personnelles qui
ne le concernent en rien 21 .
1.2.3 Principes et conseils

Au niveau auquel nous prétendons l’enseigner, la programmation ne requiert ni
grande théorie, ni connaissances encyclopédiques. Les concepts utilisés sont rudimen-
taires mais c’est leur mise en oeuvre qui est délicate. S’il n’y avait qu’un seul conseil à
donner, ce serait la règle des trois "P" :
1. Programmer
2. Programmer
3. Programmer
La pratique est effectivement essentielle. C’est ce qui fait qu’un enfant a plus de facili-
tés, puisqu’il a plus de temps. Ajoutons quand même quelques conseils de base :
1. S’amuser. C’est une évidence en matière de pédagogie. Mais c’est tellement facile
dans le cas de la programmation, qu’il serait dommage de passer à côté ! Au pire,
si programmer n’est pas toujours une partie de plaisir pour tout le monde, il vaut
mieux que le programme obtenu dans la douleur soit intéressant pour celui qui
l’a fait !
2. Bricoler. Ce que nous voulons dire par là, c’est qu’il ne faut pas hésiter à tâton-
ner, tester, fouiller, faire, défaire, casser, etc. L’ordinateur est un outil expérimen-
tal. Mais sa programmation est elle aussi une activité expérimentale à la base.
Même si le programmeur aguerri trouvera la bonne solution du premier jet, il
est important pour le débutant d’apprendre à connaître le langage et l’outil de
programmation en jouant avec eux.
3. Faire volontairement des erreurs. Provoquer les erreurs pendant la phase d’ap-
prentissage pour mieux les connaître est le meilleur moyen de comprendre beau-
coup de choses et aussi de repérer ces erreurs quand elles ne seront plus volon-
taires.
4. Rester (le) maître 22 (de la machine et de son programme). Que programmer soit
expérimental ne signifie pas pour autant qu’il faille faire n’importe quoi jusqu’à
ce que ça marche plus ou moins. Il faut avancer progressivement, méthodique-
ment, en testant au fur et à mesure, sans laisser passer la moindre erreur ou im-
précision.
19. sous Linux, le compilateur usuel est GCC (GNU Compiler Collection) et Clang sous Mac, soutenu
par Apple. Le projet GNU développe de nombreux outils indispensables et libres pour compléter le
système d’exploitation. Clang s’inspire fortement de GCC pour l’utilisation, mais dispose d’une licence
différente, qui ne ferme pas la porte à des extensions non libres.
20. Minimal GNU for Windows, une adaptation de GCC pour Windows.
21. Cette intrusion n’est plus de mise avec VisualStudio 2015, enfin !
22. Le vocabulaire n’est pas choisi au hasard : un programme est une suite d’ordres, de commandes ou
d’instructions. On voit bien qui est le chef !
12
1. Préambule 1.2. Comment apprendre ?
5. Debugger. Souvent, la connaissance du debuggeur (l’outil pour rechercher les

bugs) est négligée et son apprentissage est repoussé au stade avancé. Cet outil est
pourtant pratique pour comprendre ce qui se passe dans un programme, même
dépourvu de bugs. Il faut donc le considérer comme essentiel et faisant partie
intégrante de la conception d’un programme. Là encore, un bon environnement
de programmation facilite la tâche.
Gardons bien présents ces quelques principes car il est maintenant temps de. . .
passer à notre premier programme !
13
2. Bonjour, Monde !
Chapitre 2
Bonjour, Monde !
(Si certains collégiens sont arrivés ici, ils sont bien courageux ! Lorsque je disais tout à
l’heure qu’ils pouvaient facilement apprendre à programmer, je le pensais vraiment. Par contre,
c’est avec un peu d’optimisme que j’ai prétendu qu’ils pouvaient le faire en lisant un polycopié
destiné à des ingénieurs. Enfin, je suis pris à mon propre piège ! Alors, à tout hasard, je vais
tenter d’expliquer au passage les mathématiques qui pourraient leur poser problème.)
Si l’on en croit de nombreux manuels de programmation, un premier programme

doit toujours ressembler à ça :
# i n c l u d e <iostream >
using namespace s t d ;
i n t main ( )
{
cout << " Hello , World ! " << endl ;
return 0;
}
Eh bien, allons-y ! Décortiquons-le ! Dans ce programme, qui affiche à l’écran 1 le texte
"Hello, World!", les lignes 1 et 2 sont des instructions magiques 2 qui servent à pou-
voir utiliser dans la suite cout et endl. La ligne 4 int main() définit une fonction appelée
main(), qui renvoie 3 un nombre entier. Cette fonction est spéciale car c’est la fonction
principale d’un programme C++, celle qui est appelée automatiquement 4 quand le
1. Cette expression, vestige de l’époque où les ordinateurs étaient dotés d’un écran capable de n’affi-
cher que des caractères et non des graphiques (courbes, dessins, etc.), signifie aujourd’hui que l’affichage
se fera dans une fenêtre simulant l’écran d’un ordinateur de cette époque. Cette fenêtre est appelée ter-
minal, console, fenêtre de commande, fenêtre DOS, xterm, etc. suivant les cas. Souvenons nous avec
un minimum de respect que c’était déjà un progrès par rapport à la génération précédente, dépourvue
d’écran et qui utilisait une imprimante pour communiquer avec l’homme. . . ce qui était relativement
peu interactif !
2. Entendons par là des instructions que nous n’expliquons pas pour l’instant. Il n’y a (mal ?)-
heureusement rien de magique dans la programmation.
3. On dit aussi retourne. À qui renvoie-t-elle cet entier ? Mais à celui qui l’a appelée, voyons !
4. Voilà, maintenant vous savez qui appelle main(). Dans un programme, les fonctions s’appellent
les unes les autres. Mais main() n’est appelée par personne puisque c’est la première de toutes. (Du
moins en apparence car en réalité le programme a plein de choses à faire avant d’arriver dans main()
2. Bonjour, Monde !
programme est lancé 5 . Délimitée par les accolades ({ ligne 5 et } ligne 8), la fonction
main() se termine ligne 7 par return 0; qui lui ordonne de retourner l’entier 0. Notons
au passage que toutes les instructions se terminent par un point-virgule ;. Enfin, à la
ligne 6, seule ligne "intéressante", cout << "Hello, World!"<< endl; affiche, grâce à la
variable 6 cout qui correspond à la sortie console 7 , des données séparées par des <<. La
première de ces données est la chaîne de caractères 8 "Hello, World!". La deuxième, endl,
est un retour à la ligne 9 .
Ouf ! Que de termes en italique. Que de concepts à essayer d’expliquer ! Et pour

un programme aussi simple ! Mais là n’est pas le problème. Commencer par expliquer
ce programme, c’est être encore dans le vide, dans le magique, dans l’abstrait, dans
l’approximatif. Nous ne sommes pas réellement maîtres de la machine. Taper des ins-
tructions et voir ce qui se passe sans comprendre ce qui se passe n’est pas raisonnable.
En fait, c’est même très dommageable pour la suite. On ne donne pas efficacement
d’ordre à quelqu’un sans comprendre comment il fonctionne ni ce que les ordres don-
nés entraînent comme travail. De même,
on ne programme pas convenablement sans comprendre ce que l’ordinateur

aura exactement besoin de faire pour exécuter ce programme.
C’est toute cette approche qui est négligée quand on commence comme nous venons
de le faire. Donc. . .
Stop ! Stop ! Stop ! Faux départ ! On reprend le :
et il commence par plusieurs autres fonctions que le programmeur n’a pas à connaître et qui finissent
par appeler main(). D’ailleurs, si personne ne l’appelait, à qui main() retournerait-elle un entier ?)
5. Je savais bien que vouloir expliquer tous les barbarismes propres aux informaticiens m’interrom-
prait souvent. Mais bon. Donc, un programme démarre ou est lancé. Après quoi, il s’exécute ou tourne.
Enfin, il se termine ou meurt.
6. Les données sont rangées ou stockées dans des variables qui mémorisent des valeurs. Ces variables ne
sont d’ailleurs pas toujours variables au sens usuel, puisque certaines sont constantes !
7. Qu’est-ce que je disais ! On affiche dans une fenêtre console !
8. En clair, un texte.
9. Ce qui signifie que la suite de l’affichage sur la console se fera sur une nouvelle ligne.
16
2. Bonjour, Monde! 2.1. L’ordinateur
Chapitre 2 (deuxième essai)

Comment ça marche ?
Le problème avec le programme précédent est qu’il est très loin de ce qu’un ordi-
nateur sait faire naturellement. En fait, un ordinateur ne sait pas faire de C++. Il ne
sait que calculer 10 , transformer des nombres en autres nombres. Bien que peu compré-
hensible pour le débutant, un programme en C++ se veut le plus proche possible de
l’Homme, tout en restant évidemment accessible 11 à la machine. Le C++ est un lan-
gage très complet, peut-être même trop. Il peut être relativement proche de la machine
si nécessaire et au contraire de "haut niveau" quand il le faut. La largeur de son spectre
est une des raisons de son succès. C’est aussi ce qui fait que son apprentissage complet
demande un long travail et nous ne verrons ici qu’un partie restreinte du C++ !
2.1 L’ordinateur
Pour savoir ce qu’un ordinateur sait vraiment faire, il faut commencer par son or-
gane principal : le micro-processeur.
2.1.1 Le micro-processeur
Quel qu’il soit 12 et quelle que soit sa vitesse 13 , un micro-processeur ne sait faire que
des choses relativement basiques. Sans être exhaustif, retenons juste ceci :
— Il sait exécuter une suite ordonnée d’instructions.
— Il possède un petit nombre de mémoires internes appelées registres.
— Il dialogue avec le monde extérieur via de la mémoire 14 en plus grande quantité
que ses registres.
— Cette mémoire contient, sous forme de nombres, les instructions à exécuter et les
données sur lesquelles travailler.
— Les instructions sont typiquement :
— Lire ou écrire un nombre dans un registre ou en mémoire.
— Effectuer des calculs simples : addition, multiplication, etc.
— Tester ou comparer des valeurs et décider éventuellement de sauter à une
autre partie de la suite d’instructions.
10. Un computer, quoi !
11. Cette notion est évidemment dépendante de notre savoir faire informatique à l’instant présent.
Les premiers langages étaient plus éloignés de l’Homme car plus proches de la machine qui était alors
rudimentaire, et l’on peut envisager que les futurs langages seront plus proches de l’Homme.
12. Pentium ou autre
13. Plus exactement la fréquence à laquelle il exécute ses instructions. Aujourd’hui l’horloge va envi-
ron à 3GHz. (Mais attention : une instruction demande plus d’un cycle d’horloge !)
14. Aujourd’hui, typiquement 1Go (giga-octets), soit 1024 × 1024 × 1024 mémoires de 8 bits (mémoires
pouvant stocker des nombres entre 0 et 255).
17
2.1. L’ordinateur 2. Bonjour, Monde !
Voici par exemple ce que doit faire le micro-processeur quand on lui demande
d’exécuter "c=3∗a+2∗b;" en C++, où a,b,c sont trois variables entières :
00415A61 mov eax,dword ptr [a] // mettre dans le registre eax

// le contenu de l’adresse où
// est mémorisée la variable a
00415A64 imul eax,eax,3 // effectuer eax=eax*3
00415A67 mov ecx,dword ptr [b] // idem mettre b dans ecx
00415A6A lea edx,[eax+ecx*2] // effectuer edx=eax+ecx*2
00415A6D mov dword ptr [c],edx // mettre le contenu du registre edx
// à l’adresse où est mémorisée la
// variable c
Ce programme est désigné comme du Code Machine. Le nombre au début de chaque

ligne est une adresse. Nous allons en reparler. A part lui, le reste est relativement lisible
pour un humain (attention, c’est moi qui ai ajouté les remarques sur le coté droit !).
Ceci parce qu’il s’agit d’un programme en langage assembleur, c’est-à-dire un langage
où chaque instruction est vraiment une instruction du micro-processeur, mais où le
nom de ces instructions ainsi que leurs arguments sont explicites. En réalité, le micro-
processeur ne comprend pas l’assembleur. Comprendre "mov eax,dword ptr [a]"
lui demanderait non seulement de décoder cette suite de symboles, mais aussi de sa-
voir où est rangée la variable a. Le vrai langage du micro-processeur est le langage
machine, dans lequel les instructions sont des nombres. Voici ce que ça donne pour
notre "c=3∗a+2∗b;" :
00415A61 8B 45 F8
00415A64 6B C0 03
00415A67 8B 4D EC
00415A6A 8D 14 48
00415A6D 89 55 E0
A part encore une fois la colonne de gauche, chaque suite de nombres 15 correspond
évidemment à une instruction précise. C’est tout de suite moins compréhensible 16 !
Notons que chaque micro-processeur à son jeu d’instructions ce qui veut dire que la tra-
duction de c=3∗a+2∗b; en la suite de nombres 8B45F86BC0038B4DEC8D14488955E0
est propre au Pentium que nous avons utilisé pour notre exemple :
Une fois traduit en langage machine pour un micro-processeur donné, un

programme C++ n’a de sens que pour ce micro-processeur.
Remarquons aussi que les concepteurs du Pentium ont décidé de créer une instruction
spécifique pour calculer edx=eax+ecx∗2 en une seule fois car elle est très fréquente. Si
on avait demandé c=3∗a+3∗b;, notre programme serait devenu :
00415A61 8B 45 F8 mov eax,dword ptr [a]

00415A64 6B C0 03 imul eax,eax,3
00415A67 8B 4D EC mov ecx,dword ptr [b]
15. Nombres un peu bizarres, certes, puisqu’il contiennent des lettres. Patience, jeune Padawan ! Nous
en reparlons aussi tout de suite !
16. Et pourtant, les informaticiens programmaient comme cela il n’y a pas si longtemps. C’était déjà
très bien par rapport à l’époque antérieure où il fallait programmer en base 2. . . et beaucoup moins bien
que lorsqu’on a pu enfin programmer en assembleur !
18
2. Bonjour, Monde ! 2.1. L’ordinateur
00415A6A 6B C9 03 imul ecx,ecx,3

00415A6D 03 C1 add eax,ecx
00415A6F 89 45 E0 mov dword ptr [c],eax
car "lea edx,[eax+ecx*3]" n’existe pas !

Mais revenons à nos nombres. . .
2.1.2 La mémoire
La mémoire interne du micro-processeur est gérée dans des registres, un peu comme
les variables du C++, mais en nombre prédéfini. Pour stocker 17 la suite d’instructions à
lui fournir, on utilise de la mémoire en quantité bien plus importante, désignée en gé-
néral par la mémoire de l’ordinateur. Il s’agit des fameuses "barrettes" 18 de mémoire que
l’on achète pour augmenter la capacité de sa machine et dont les prix fluctuent assez
fortement par rapport au reste des composants d’un ordinateur. Cette mémoire est dé-
coupée en octets. Un octet 19 correspond à un nombre binaire de 8 bits 20 , soit à 28 = 256
valeurs possibles. Pour se repérer dans la mémoire, il n’est pas question de donner des
noms à chaque octet. On numérote simplement les octets et on obtient ainsi des adresses
mémoire. Les nombres 00415A61, etc. vus plus haut sont des adresses ! Au début, ces
nombres étaient écrits en binaire, ce qui était exactement ce que comprenait le micro-
processeur. C’est devenu déraisonnable quand la taille de la mémoire a dépassé les
quelques centaines d’octets. Le contenu d’un octet de mémoire étant lui aussi donné
sous la forme d’un nombre, on a opté pour un système adapté au fait que ces nombres
sont sur 8 bits : plutôt que d’écrire les nombre en binaire, le choix de la base 16 per-
mettait de représenter le contenu d’un octet sur deux chiffres (0,1,. . . ,9,A,B,C,D,E,F).
Le système hexadécimal 21 était adopté. . . Les conversions de binaire à hexadécimal sont
très simples, chaque chiffre hexadécimal valant pour un paquet de 4 bits, alors qu’entre
binaire et décimal, c’est moins immédiat. Il est aujourd’hui encore utilisé quand on dé-
signe le contenu d’un octet ou une adresse 22 . Ainsi, notre fameux c=3∗a+2∗b; devient
en mémoire :
17. Encore un anglicisme. . .
18. Aujourd’hui, typiquement une ou plusieurs barrettes pour un total de 1 ou 2Go, on l’a déjà dit.
Souvenons nous avec une larme à l’oeil des premiers PC qui avaient 640Ko (kilo-octet soit 1024 octets),
voire pour les plus agés d’entre nous des premiers ordinateurs personnels avec 4Ko, ou même des
premières cartes programmables avec 256 octets !
19. byte en anglais. Attention donc à ne pas confondre byte et bit, surtout dans des abréviations comme
512kb/s données pour le débit d’un accès internet. . . b=bit, B=byte=8 bits
20. Le coin des collégiens : en binaire, ou base 2, on compte avec deux chiffres au lieu de dix d’ha-
bitude (c’est à dire en décimal ou base 10). Cela donne : 0, 1, 10, 11, 100, 101, 110, 111, . . . Ainsi, 111 en
binaire vaut 7 . Chaque chiffre s’appelle un bit. On voit facilement qu’avec un chiffre on compte de 0 à
1 soit deux nombres possibles ; avec deux chiffres, de 0 à 3, soit 4 = 2 × 2 nombres ; avec 3 chiffres, de
0 à 7, soit 8 = 2 × 2 × 2 nombres. Bref avec n bits, on peut coder 2n (2 multiplié par lui-même n fois)
nombres. Je me souviens avoir appris la base 2 en grande section de maternelle avec des cubes en bois !
Étrange programme scolaire. Et je ne dis pas ça pour me trouver une excuse d’être devenu informaticien.
Quoique. . .
21. Coin des collégiens (suite) : en base 16, ou hexadécimal, on compte avec 16 chiffres. Il faut inven-
ter des chiffres au delà de 9 et on prend A,B,C,D,E,F. Quand on compte, cela donne : 0, 1, 2, . . . , 9, A, B,
C, D, E, F, 10, 11, 12, 13, . . . , 19, 1A, 1B, 1C, . . . Ainsi 1F en hexadécimal vaut 31. Avec 1 chiffre, on compte
de 0 à 15 soit 16 nombres possibles ; avec 2 chiffres, de 0 à 255 soit 256 = 16 × 16 nombres possibles, etc.
Un octet peut s’écrire avec 8 bits en binaire, ou 2 nombres en hexadécimal et va de 0 à 255, ou 11111111
en binaire, ou FF en hexadécimal.
22. Dans ce cas, sur plus de 2 chiffres : 8 pour les processeurs 32 bits, 16 pour les processeurs 64 bits.
19
2.1. L’ordinateur 2. Bonjour, Monde !
adresse mémoire contenu représente

00415A61 8B
00415A62 45 mov eax,dword ptr [a]
00415A63 F8
00415A64 6B
00415A65 C0 imul eax,eax,3
... ...
La mémoire ne sert pas uniquement à stocker la suite d’instructions à exécuter mais

aussi toutes les variables et données du programme, les registres du micro-processeur
étant insuffisants. Ainsi nos variables a,b,c sont stockées quelque part en mémoire sur
un nombre d’octets suffisant 23 pour représenter des nombres entiers (ici 4 octets) et
dans un endroit décidé par le C++, de telle sorte que l’instruction 8B45F8 aille bien
chercher la variable a ! C’est un travail pénible, que le C++ fait pour nous et que les
programmeurs faisaient autrefois à la main 24 . Bref, on a en plus 25 :
adresse mémoire contenu représente

... ...
00500000 a1
00500001 a2 a
00500002 a3
00500003 a4
00500004 b1
00500005 b2 b
00500006 b3
00500007 b4
... ...
où les octets a1 , . . . , a4 combinés donnent l’entier a sur 32 bits. Certains processeurs

(dits big-endian) 26 décident a = a1 a2 a3 a4 , d’autres (little-endian) 27 que a = a4 a3 a2 a1 .
Cela signifie que :
Tout comme pour les instructions, un nombre stocké par un micro-

processeur dans un fichier peut ne pas être compréhensible par un autre
micro-processeur qui relit le fichier !
23. Les variables ayant plus de 256 valeurs possibles sont forcément stockées sur plusieurs octets.
Ainsi, avec 4 octets on peut compter en binaire sur 4 × 8 = 32 bits, soit 232 valeurs possibles (plus de 4
milliards).
24. Ce qui était le plus pénible n’était pas de décider où il fallait ranger les variables en mémoire, mais
d’ajuster les instructions en conséquence. Si on se trompait, on risquait d’écrire au mauvais endroit de
la mémoire. Au mieux, cela effaçait une autre variable — ce comportement est encore possible de nos
jours — au pire, cela effaçait des instructions et le programme pouvait faire de "grosses bêtises" — ceci
est aujourd’hui impossible sous Windows ou Linux, et ne concerne plus que certains systèmes.
25. Nous faisons ici un horrible mensonge à des fins simplificatrices. Dans notre cas, les variables
étaient des variables locales à la fonction main() donc stockées dans la pile. Elles ne sont pas à une
adresse mémoire définie à l’avance de manière absolue mais à une adresse relative à l’emplacement
où la fonction rangera ses variables locales en fonction de ce que le programme aura fait avant. Cela
explique la simplicité de l’instruction mov eax,dword ptr [a] dans notre cas. Nous verrons tout
cela plus tard.
26. Comme les PowerPC des vieux Macs
27. Comme les processeurs Intel et AMD
20
2. Bonjour, Monde ! 2.1. L’ordinateur
2.1.3 Autres Composants

Micro-processeur et mémoire : nous avons vu le principal. Complétons le tableau
avec quelques autres éléments importants de l’ordinateur.
Types de mémoire
La mémoire dont nous parlions jusqu’ici est de la mémoire vive ou RAM. Elle est
rapide 28 mais a la mauvaise idée de s’effacer quand on éteint l’ordinateur. Il faut donc
aussi de la mémoire morte ou ROM, c’est-à-dire de la mémoire conservant ses données
quand l’ordinateur est éteint mais qui en contre-partie ne peut être modifiée 29 . Cette
mémoire contient en général le minimum pour que l’ordinateur démarre et exécute
une tâche prédéfinie. Initialement, on y stockait les instructions nécessaires pour que le
programmeur puisse remplir ensuite la RAM avec les instructions de son programme.
Il fallait retaper le programme à chaque fois 30 ! On a donc rapidement eu recours à des
moyens de stockage pour sauver programmes et données à l’extinction de l’ordinateur. Il
suffisait alors de mettre en ROM le nécessaire pour gérer ces moyens de stockages.
Moyens de stockage
Certains permettent de lire des données, d’autres d’en écrire, d’autres les deux à
la fois. Certains ne délivrent les données que dans l’ordre, de manière séquentielle,
d’autres, dans l’ordre que l’on veut, de manière aléatoire. Ils sont en général bien plus
lents que la mémoire et c’est sûrement ce qu’il faut surtout retenir ! On recopie donc en
RAM la partie des moyens de stockage sur laquelle on travaille.
Faire travailler le micro-processeur avec le disque dur est BEAUCOUP plus

lent qu’avec la mémoire (1000 fois plus lent en temps d’accès, 100 fois plus
en débit) a
a. Rajoutez un facteur 50 supplémentaire entre la mémoire et la mémoire cache du proces-
seur !
Au début, les moyens de stockages étaient mécaniques : cartes ou bandes perfo-

rées. Puis ils devinrent magnétiques : mini-cassettes 31 , disquettes 32 , disques durs 33 ou
bandes magnétiques. Aujourd’hui, on peut rajouter les CD, DVD, les cartes mémoire,
les "clés USB", etc, etc.
28. Moins que les registres, ou même que le cache mémoire du processeur, dont nous ne parlerons pas
ici.
29. Il est pénible qu’une ROM ne puisse être modifiée. Alors, à une époque, on utilisait des mémoires
modifiables malgré tout, mais avec du matériel spécialisé (EPROMS). Maintenant, on a souvent recours
à de la mémoire pouvant se modifier de façon logicielle (mémoire "flashable") ou, pour de très petites
quantités de données, à une mémoire consommant peu (CMOS) et complétée par une petite pile. Dans
un PC, la mémoire qui sert à démarrer s’appelle le BIOS. Il est flashable et ses paramètres de règlage
sont en CMOS. Attention à l’usure de la pile !
30. A chaque fois qu’on allumait l’ordinateur mais aussi à chaque fois que le programme plantait et
s’effaçait lui-même, c’est-à-dire la plupart du temps !
31. Très lent et très peu fiable, mais le quotidien des ordinateurs personnels.
32. Le luxe. Un lecteur de 40Ko coûtait 5000F !
33. Les premiers étaient de véritables moteurs de voiture, réservés aux importants centres de calcul.
21
2.2. Système d’exploitation 2. Bonjour, Monde !
Périphériques
On appelle encore périphériques différents appareils reliés à l’ordinateur : clavier,
souris, écran, imprimante, modem, scanner, etc. Ils étaient initialement là pour servir
d’interface avec l’Homme, comme des entrées et des sorties entre le micro-processeur
et la réalité. Maintenant, il est difficile de voir encore les choses de cette façon. Ainsi
les cartes graphiques, qui pouvaient être considérées comme un périphérique allant
avec l’écran, sont-elles devenues une partie essentielle de l’ordinateur, véritables puis-
sances de calcul, à tel point que certains programmeur les utilisent pour faire des cal-
culs sans même afficher quoi que ce soit. Plus encore, c’est l’ordinateur qui est parfois
juste considéré comme maillon entre différents appareils. Qui appellerait périphérique
un caméscope qu’on relie à un ordinateur pour envoyer des vidéos sur internet ou les
transférer sur un DVD ? Ce serait presque l’ordinateur qui serait un périphérique du
caméscope !
2.2 Système d’exploitation

Notre vision jusqu’ici est donc la suivante :
1. Le processeur démarre avec les instructions présentes en ROM.
2. Ces instructions lui permettent de lire d’autres instructions présentes sur le disque
dur et qu’il recopie en RAM.
3. Il exécute les instructions en question pour y lire des données (entrées) présentes
elles-aussi sur le disque dur et générer de nouvelles données (sorties). A moins
que les entrées ou les sorties ne soient échangées via les périphériques.
Assez vite, ce principe a évolué :
1. Le contenu du disque dur a été organisé en fichiers. Certains fichiers représen-
taient des données 34 , d’autres des programmes 35 , d’autres encore contenaient
eux-mêmes des fichiers 36 .
2. Les processeurs devenant plus rapides et les capacités du disque dur plus impor-
tantes, on a eu envie de gérer plusieurs programmes et d’en exécuter plusieurs :
l’un après l’autre, puis plusieurs en même temps (multi-tâches), puis pour plu-
sieurs utilisateurs en même temps (multi-utilisateurs) 37 , enfin avec plusieurs pro-
cesseurs par machine.
Pour gérer tout cela, s’est dégagé le concept de système d’exploitation 38 . Windows, Unix
(dont linux) et MAC/OS sont les plus répandus. Le système d’exploitation est aujour-
d’hui responsable de gérer les fichiers, les interfaces avec les périphériques ou les uti-
lisateurs 39 , mais son rôle le plus délicat est de gérer les programmes (ou tâches ou
34. Les plus courantes étaient les textes, où chaque octet représentait un caractère. C’était le célèbre
code ASCII (65 pour A, 66 pour B, etc.). A l’ère du multimédia, les formats sont aujourd’hui nombreux,
concurrents, et plus ou moins normalisés.
35. On parle de fichier exécutable. . .
36. Les répertoires.
37. Aujourd’hui, c’est pire. Un programme est souvent lui même en plusieurs parties s’exécutant en
même temps (les threads). Quant au processeur, il exécute en permanence plusieurs instructions en même
temps (on dit qu’il est super-scalaire) !
38. Operating System
39. Espérons qu’un jour les utilisateurs ne seront pas eux-aussi des périphériques !
22
2. Bonjour, Monde ! 2.3. La Compilation
process) en train de s’exécuter. Il doit pour cela essentiellement faire face à deux pro-
blèmes 40 :
1. Faire travailler le processeur successivement par petites tranches sur les diffé-
rents programmes. Il s’agit de donner la main de manière intelligente et équi-
table, mais aussi de replacer un process interrompu dans la situation qu’il avait
quittée lors de son interruption.
2. Gérer la mémoire dédiée à chaque process. En pratique, une partie ajustable de
la mémoire est réservée à chaque process. La mémoire d’un process devient mé-
moire virtuelle : si un process est déplacé à un autre endroit de la mémoire physique
(la RAM), il ne s’en rend pas compte. On en profite même pour mettre tempo-
rairement hors RAM (donc sur disque dur) un process en veille. On peut aussi
utiliser le disque dur pour qu’un process utilise plus de mémoire que la mémoire
physique : mais attention, le disque étant très lent, ce process risque de devenir
lui aussi très lent.
Lorsqu’un process à besoin de trop de mémoire, il utilise, sans préve-
nir, le disque dur à la place de la mémoire et peut devenir très lent.
On dit qu’il swappe (ou pagine). Seule sa lenteur (et le bruit du disque
dur !) permet en général de s’en rendre compte (on peut alors s’en as-
surer avec le gestionnaire de tâche du système).
Autre progrès : on gère maintenant la mémoire virtuelle de façon à séparer les
process entre eux et, au sein d’un même process, la mémoire contenant les ins-
tructions de celle contenant les données. Il est rigoureusement impossible qu’un
process buggé puisse modifier ses instructions ou la mémoire d’un autre process
en écrivant à un mauvais endroit de la mémoire 41 .
Avec l’arrivée des systèmes d’exploitation, les fichiers exécutables ont dû s’adapter
pour de nombreuse raisons de gestion et de partage de la mémoire. En pratique, un
programme exécutable linux ne tournera pas sous Windows et réciproquement, même
s’ils contiennent tous les deux des instructions pour le même processeur.
Un fichier exécutable est spécifique, non seulement à un processeur donné,
mais aussi à un système d’exploitation donné.
Au mieux, tout comme les versions successives d’une famille de processeur essaient
de continuer à comprendre les instructions de leurs prédécesseurs, tout comme les
versions successives d’un logiciel essaient de pouvoir lire les données produites avec
les versions précédentes, les différentes versions d’un système d’exploitation essaient
de pouvoir exécuter les programmes faits pour les versions précédentes. C’est la com-
patibilité ascendante, que l’on paye souvent au prix d’une complexité et d’une lenteur
accrues.
2.3 La Compilation
Tout en essayant de comprendre ce qui se passe en dessous pour en tirer des infor-
mations utiles comme la gestion de la mémoire, nous avons entrevu que transformer
40. Les processeurs ont évidemment évolué pour aider le système d’exploitation à faire cela
efficacement.
41. Il se contente de modifier anarchiquement ses données, ce qui est déjà pas mal !
23
2.3. La Compilation 2. Bonjour, Monde !
un programme C++ en un fichier exécutable est un travail difficile mais utile. Cer-
tains logiciels disposant d’un langage de programmation comme Maple ou Scilab ne
transforment pas leurs programmes en langage machine. Le travail de traduction est
fait à l’exécution du programme qui est alors analysé au fur et à mesure 42 : on parle
alors de langage interprété. L’exécution alors est évidemment très lente. D’autres lan-
gages, comme Java, décident de résoudre les problèmes de portabilité, c’est-à-dire de
dépendance au processeur et au système, en plaçant une couche intermédiaire entre
le processeur et le programme : la machine virtuelle. Cette machine, évidemment écrite
pour un processeur et un système donnés, peut exécuter des programmes dans un
langage machine virtuel 43 , le "byte code". Un programme Java est alors traduit en son
équivalent dans ce langage machine. Le résultat peut être exécuté sur n’importe quelle
machine virtuelle Java. La contrepartie de cette portabilité est évidemment une perte
d’efficacité.
La traduction en code natif ou en byte code d’un programme s’appelle la compila-
tion 44 . Un langage compilé est alors à opposer à un langage interprété. Dans le cas du C++
et de la plupart des langages compilés (Fortran, C, etc), la compilation se fait vers du
code natif. On transforme un fichier source, le programme C++, en un fichier objet, suite
d’instructions en langage machine.
Cependant, le fichier objet ne se suffit pas à lui-même. Des instructions supplémen-
taires sont nécessaires pour former un fichier exécutable complet :
— de quoi lancer le main() ! Plus précisément, tout ce que le process doit faire avant
et après l’exécution de main().
— des fonctions ou variables faisant partie du langage et que le programmeur uti-
lise sans les reprogrammer lui-même, comme l’objet cout, la fonction min(), etc.
L’ensemble de ces instructions constitue ce qu’on appelle une bibliothèque 45 .
— des fonctions ou variables programmées par le programmeur lui-même dans
d’autres fichiers source compilés par ailleurs en d’autres fichiers objet, mais qu’il
veut utiliser dans son programme actuel.
La synthèse de ces fichiers en un fichier exécutable s’appelle l’édition des liens. Le pro-
gramme qui réalise cette opération est plus souvent appelé linker qu’éditeur de liens. . .
En résumé, la production du fichier exécutable se fait de la façon suivante :

1. Compilation : fichier source → fichier objet.
2. Link : fichier objet + autres fichiers objets + bibliothèque standard ou
autres → fichier exécutable.
42. même s’il est parfois pré-traité pour accélérer l’exécution.

43. Par opposition, le "vrai" langage machine du processeur est alors appelé code natif.
44. Les principes de la compilation sont une des matières de base de l’informatique, traditionnelle et
très formatrice. Quand on sait programmer un compilateur, on sait tout programmer (Évidemment, un
compilateur est un programme ! On le programme avec le compilateur précédent ! Même chose pour les
systèmes d’exploitation. . . ). Elle nécessite un cours à part entière et nous n’en parlerons pas ici !
45. Une bibliothèque est en fait un ensemble de fichiers objets pré-existants regroupés en un seul fi-
chier. Il peut s’agir de la bibliothèque des fonctions faisant partie de C++, appelée bibliothèque standard,
mais aussi d’une bibliothèque supplémentaire fournie par un tiers.
24
2. Bonjour, Monde ! 2.4. L’environnement de programmation
2.4 L’environnement de programmation

L’environnement de programmation 46 est le logiciel permettant de programmer.
Dans notre cas il s’agit de QtCreator. Dans d’autres cas, il peut simplement s’agir
d’un ensemble de programmes. Un environnement contient au minimum un éditeur
pour créer les fichiers sources, un compilateur/linker pour créer les exécutables, un de-
buggeur pour traquer les erreurs de programmation, et un gestionnaire de projet pour
gérer les différents fichiers sources et exécutables avec lesquels on travaille.
Nous reportons ici le lecteur au texte du premier TP et à l’appendice C. En plus de
quelques notions rudimentaires de C++ que nous verrons au chapitre suivant, quelques
informations supplémentaires sont utiles pour le suivre.
2.4.1 Noms de fichiers

L’extension (le suffixe) sert à se repérer dans les types de fichier :
— Un fichier source C++ se terminera par .cpp 47 .
— Un fichier objet sera en .obj (Windows) ou .o (Linux/Mac)
— Un fichier exécutable en .exe (Windows) ou sans extension (Linux/Mac)
Nous verrons aussi plus loin dans le cours :
— Les "en-tête" C++ ou headers servant à être inclus dans un fichier source : fichiers
.h
— Les bibliothèques (ensembles de fichiers objets archivés en un seul fichier) : fi-
chiers .lib ou .dll (Windows) ou .a ou .so (Linux/Mac)
2.4.2 Debuggeur
Lorsqu’un programme ne fait pas ce qu’il faut, on peut essayer de comprendre ce
qui ne va pas en truffant son source d’instructions pour imprimer la valeur de certaines
données ou simplement pour suivre son déroulement. Ça n’est évidemment pas très
pratique. Il est mieux de pouvoir suivre son déroulement instruction par instruction et
d’afficher à la demande la valeur des variables. C’est le rôle du debuggeur 48 .
Lorsqu’un langage est interprété, il est relativement simple de le faire s’exécuter pas
à pas car c’est le langage lui-même qui exécute le programme. Dans le cas d’un langage
compilé, c’est le micro-processeur qui exécute le programme et on ne peut pas l’arrêter
à chaque instruction ! Il faut alors mettre en place des points d’arrêt en modifiant tem-
porairement le code machine du programme pour que le processeur s’arrête lorsqu’il
atteint l’instruction correspondant à la ligne de source à debugger. Si c’est compliqué
à mettre au point, c’est très simple à utiliser, surtout dans un environnement de pro-
grammation graphique.
Nous verrons au fur et à mesure des TP comment le debuggeur peut aussi inspecter
les appels de fonctions, espionner la modification d’une variable, etc.
46. souvent appelé IDE, Integrated Development Environment.

47. Un fichier en .c sera considéré comme du C.
48. Débogueur en français !
25
2.5. Le minimum indispensable 2. Bonjour, Monde !
2.5 Le minimum indispensable

2.5.1 Pour comprendre le TP
Voici le programme C++ strictement minimal, écrit dans un fichier main.cpp :
i n t main ( ) { }
Le mot réservé main indique le point d’entrée du programme. C’est une fonction (un
bloc de code). Comme une fonction mathématique elle prend une ou plusieurs entrées
et a une valeur de retour. Pour cette fonction, il n’y a rien entre les parenthèses, ce
qui signifie qu’elle n’a pas d’argument en entrée. Par contre, elle retourne une valeur
entière (type int comme integer). Cette fonction ne fait rien, la liste de ses instructions
est vide (bloc entre accolades). Mais quelle est la valeur retournée par cette fonction ?
Cette fonction retourne la valeur 0, qui par convention indique que tout est normal
pour ce programme. Pour être plus explicite, il aurait mieux valu écrire
i n t main ( ) {
return 0;
}
ce qui a exactement le même effet, car la fonction main retourne 0 si on ne le précise
pas. Mais le cas de cette fonction est spécial, il est préférable d’être plus explicite et de
préciser qu’on retourne la valeur 0. Notons au passage qu’on a écrit l’ordre return
sur une nouvelle ligne, que comme toute instruction elle se termine avec point-virgule
obligatoire, et qu’on a décalé cette instruction vers la droite (on dit “indenté”) pour
bien montrer qu’on est à l’intérieur du bloc. Le compilateur est indifférent aux retours
à la ligne et aux indentations, ils sont présents uniquement pour faciliter la lecture pour
nous, le programmeur. Cependant, ne les considérez pas comme optionnels, il est pri-
mordial d’écrire un programme propre et lisible. Pour ceux qui connaissent ce langage,
notez que le Python se passe des accolades et marque un bloc par l’indentation, qui de-
vient obligatoire. Le fait que celle-ci ne soit pas significative en C++ ne veut pas dire
qu’on doit faire n’importe quoi. Insistons donc déjà sur le fait qu’il faut indenter.
Ce programme ne fait rien, mais il faut quand même vérifier qu’il est correct, c’est-
à-dire qu’il respecte la syntaxe et qu’il suffit à créer un programme exécutable. Pour
cela, nous allons utiliser Cmake, qui a l’avantage d’être multi plates-formes et d’être
compatible avec tous les environnements de développement courants. Créons donc
un fichier CMakeLists.txt de contenu suivant :
a d d _ e x e cu ta bl e ( E s s a i Q t C r e a t o r main . cpp )
Cela indique qu’on a un fichier de code source, main.cpp, et que notre programme
exécutable s’appelera EssaiQtCreator. On écrit ce fichier dans le même dossier que
le fichier source main.cpp, dossier source). On lance QtCreator et l’option “Open file
or project” dans le menu File. On lui donne le fichier CMakeLists.txt comme pro-
jet. Dans la fenêtre de configuration, on sélectionne un dossier où générer les fichiers
(dossier de build). Pour cela, cliquer sur Browse et créer un nouveau dossier, puis cli-
quer le bouton “Configure project”. On peut voir un message du type
-- Configuring done
-- Generating done
-- Build files have been written to: /home/pascal/TEMP/Build
26
2. Bonjour, Monde ! 2.5. Le minimum indispensable
F IGURE 2.1 – QtCreator après compilation du programme de test
En coulisses, QtCreator a lancé le programme CMake et on voit les messages d’infor-

mation de ce programme. Allons voir dans ce dossier /home/pascal/TEMP/Build.
On y trouve entre autres le fichier CMakeCache.txt, qui a été généré. Celui-ci contient
des variables que nous changerons plus tard. Dans QtCreator, cliquer sur le marteau
pour lancer la phase de compilation. C’est la même effet que lancer l’option “Build all”
du menu “Build”. On peut constater Figure 2.1 dans la fenêtre “Compile Output” ce
qu’il a fait :
— créer le fichier main.cpp.o en compilant main.cpp ;
— édition de liens “Linking. . . ” ;
— création du programme exécutable EssaiQtCreator.
On peut vérifier l’existence de ce programme dans le répertoire de build. Le triangle
vert permet de lancer le programme depuis QtCreator qui indique dans la fenêtre “Ap-
plication Output” :
Starting /home/pascal/TEMP/Build/EssaiQtCreator...
/home/pascal/TEMP/Build/EssaiQtCreator exited with code 0
Le programme s’est bien lancé et est sorti avec la valeur 0.
2.5.2 Un peu plus. . .

On se sert aussi dans le TP du cout qui signifie “character output” et qui permet
d’afficher ce qu’on veut dans le terminal (endl signifie end of line, retour à la ligne). On
pourra aussi tester le cin qui permet de lire dans le terminal ce qu’entre l’utilisateur :
i n t i =2 , j ;
cout << " i = " <> j ;
cout << " Le double de " << j << " e s t " << 2∗ j << endl ;
27
2.5. Le minimum indispensable 2. Bonjour, Monde !
F IGURE 2.2 – QtCreator configuré pour compiler en mode Debug.
A noter que le terminal intégré de QtCreator ne supporte pas l’entrée par l’utilisateur.
Il faut donc lancer avec un terminal extérieur, en allant dans l’onglet Projects, rubrique
Run et cliquer le bouton “Run in terminal”.
Enfin, le TP utilise la commande conditionnelle if - else.
2.5.3 Le debuggeur
Il est important de pouvoir suivre pas à pas le programme au cours de son exécu-
tion, consulter la valeur des variables, etc. Pour cela, il faut compiler dans un mode
spécial, dit Debug. Cela se fait avec une variable de CMake, qu’on peut modifier di-
rectement dans le fichier CMakeCache.txt, ou mieux sans quitter QtCreator : dans
l’onglet Projects, passer comme argument à CMake -DCMAKE_BUILD_TYPE=Debug,
puis recompiler (voir Figure 2.2). À noter que les versions récentes de QtCreator per-
mettent de passer en mode Debug plus simplement en cliquant sur le bon bouton. La
touche F9 permet de mettre un point d’arret à la ligne courante.
2.5.4 TP
Vous devriez maintenant aller faire le TP en annexe A.1. Si la pratique est essen-
tielle, en retenir quelque chose est indispensable ! Vous y trouverez aussi comment ins-
taller les outils sur votre ordinateur (lien http://imagine.enpc.fr/~monasse/
Imagine++ mentionné à la fin du TP). Voir en Figure 2.3 ce qu’il faut retenir du TP.
—
Nous en savons maintenant assez pour apprendre un peu de C++. . .
Nous commençons maintenant à nous fabriquer une “fiche de référence” qui servira
d’aide mémoire lorsqu’on est devant la machine. Nous la compléterons après chaque
chapitre avec ce qui est vu dans le chapitre. Les nouveautés par rapport à la fiche
précédente sont en rouge. La fiche finale est en annexe D.
28
2. Bonjour, Monde ! 2.5. Le minimum indispensable
1. Sous Windows, toujours travailler en local et sauvegarder sur le

disque partagé, clé USB, etc.
2. Utiliser CMake pour construire une solution Windows.
3. Nettoyer (“clean”) quand on quitte.
4. Lancer directement une exécution sauve et génère automatiquement.
Attention toutefois de ne pas confirmer l’exécution si la génération
s’est mal passée.
5. Double-cliquer sur un message d’erreur positionne l’éditeur sur l’er-
reur.
6. Toujours bien indenter.
7. Ne pas laisser passer des warnings !
8. Savoir utiliser le debuggeur.
9. Touches utiles :
F5 = = Debug/Continue
F10 = = Step over
F11 = = Step inside
Ctrl+A, Ctrl+I (QtCreator) = Indent selection
F IGURE 2.3 – Ce qu’il faut retenir du TP 1
Fiche de référence (1/1)

Entrées/Sorties Clavier — Nettoyer en quittant.
— Debug : F5 — Erreurs et warnings : cliquer.
— #include <iostream>
using namespace std; — Step over : F10
— Indenter.
... — Step inside : F11
cout <<"I="<<i<<endl; — Ne pas laisser de warning.
— Indent : Ctrl+A,Ctrl+I
cin >> i >> j; — Utiliser le debuggeur.
Conseils
29
3. Premiers programmes
Chapitre 3
Premiers programmes
Parés à expérimenter au fur et à mesure avec notre environnement de programmation, il est

temps d’apprendre les premiers rudiments du C++. Nous allons commencer par programmer
n’importe comment. . . puis nous ajouterons un minimum d’organisation en apprenant à faire
des fonctions.
On organise souvent un manuel de programmation de façon logique par rapport

au langage, en différents points successifs : les expressions, les fonctions, les variables,
les instructions, etc. Le résultat est indigeste car il faut alors être exhaustif sur chaque
point. Nous allons plutôt ici essayer de voir les choses telles qu’elles se présentent
quand on apprend : progressivement et sur un peu tous les sujets à la fois 1 ! Ainsi, ce
n’est que dans un autre chapitre que nous verrons la façon dont les fonctions mémo-
risent leurs variables dans la "pile".
3.1 Tout dans le main() !

Rien dans les mains, rien dans les poches. . . mais tout dans le main(). Voici comment
un débutant programme 2 .
C’est déjà une étape importante que de programmer au kilomètre, en plaçant

l’intégralité du programme dans la fonction main(). L’essentiel est avant
tout de faire un programme qui marche !
3.1.1 Variables
Types
Les variables sont des mémoires dans lesquelles sont stockées des valeurs (ou don-
nées). Une donnée ne pouvant être stockée n’importe comment, il faut à chaque fois dé-
cider de la place prise en mémoire (nombre d’octets) et du format, c’est-à-dire de la façon
dont les octets utilisés vont représenter les valeurs prises par la variable. Nous avons
1. La contre-partie de cette présentation est que ce polycopié, s’il est fait pour être lu dans l’ordre, est
peut-être moins adapté à servir de manuel de référence. .
2. Et bien des élèves, dès que le professeur n’est plus derrière !
3.1. Tout dans le main() ! 3. Premiers programmes
déjà rencontré les int qui sont le plus souvent aujourd’hui stockés sur quatre octets,
soit 32 bits, et pouvant prendre 232 = 4294967296 valeurs possibles 3 . Par convention,
les int stockent les nombres entiers relatifs 4 , avec autant de nombres négatifs que de
nombres positifs 5 , soit, dans le cas de 32 bits 6 , de −2147483648 à 2147483647 suivant
une certaine correspondance avec le binaire 7 .
Dire qu’une variable est un int, c’est préciser son type. Certains langages n’ont pas
la notion de type ou essaient de deviner les types des variables. En C++, c’est initia-
lement pour préciser la mémoire et le format des variables qu’elles sont typées. Nous
verrons que le compilateur se livre à un certain nombre de vérifications de cohérence
de type entre les différentes parties d’un programme. Ces vérifications, pourtant bien
pratiques, n’étaient pas faites dans les premières versions du C, petit frère du C++, car
avant tout, répétons-le :
Préciser un type, c’est préciser la place mémoire et le format d’une variable.

Le compilateur, s’il pourra mettre cette information à profit pour détecter
des erreurs de programmation, en a avant tout besoin pour traduire le source
C++ en langage machine.
Définition, Affectation, Initialisation, Constantes

Avant de voir d’autres types de variables, regardons sur un exemple la syntaxe à
utiliser :
1 int i ; / / Définition
2 i =2; // Affectation
3 cout << i << " " ;
4 int j ;
5 j=i ;
6 i =1; / / Ne m o d i f i e que i , p a s j !
7 cout << i << " " << j << " " ;
8 i n t k , l ,m; / / D é f i n i t i o n m u l t i p l e
9 k= l = 3 ; / / Affectation multiple
10 m= 4 ;
11 cout << k << " " << l << " " << m << " " ;
12 i n t n=5 , o=n , p=INT_MAX ; / / I n i t i a l i s a t i o n s
13 cout << n << " " << o << " " << p << endl ;
14 i n t q=r = 4 ; / / E r r e u r !
15 const i n t s =12;
16 s =13; / / Erreur !
3. Nous avons aussi vu que cette simple idée donne déjà lieu à deux façons d’utiliser les 4 octets :
big-endian ou little-endian.
4. Coin des collégiens : c’est à dire 0, 1, 2, . . . mais aussi −1, −2, −3, . . .
5. à un près !
6. En fait, les int s’adaptent au processeur et un programme compilé sur un processeur 64 bits aura
des int sur 64 bits ! Si l’on a besoin de savoir dans quel cas on est, le C++ fournit les constantes INT_MIN
et INT_MAX qui sont les valeurs minimales et maximales prises par les int.
7. Là, tout le monde fait pareil ! On compte en binaire à partir de 0, et arrivé à 2147483647, le suivant
est -2147483648, puis -2147483647 et ainsi de suite jusqu’à -1. On a par exemple : 0 = 000 . . . 000, 1 =
000 . . . 001, 2147483647 = 011 . . . 111, −2147483648 = 100 . . . 000, −2147483647 = 100..001, −2 =
111 . . . 110, −1 = 111 . . . 111
32
3. Premiers programmes 3.1. Tout dans le main() !
Dans ce programme :
— Les lignes 1 et 2 définissent une variable nommée i 8 de type int puis affecte
2 à cette variable. La représentation binaire de 2 est donc stockée en mémoire
là où le compilateur décide de placer i. Ce qui suit le "double slash" ( // ) est une
remarque : le compilateur ignore toute la fin de la ligne, ce qui permet de mettre
des commentaires aidant à la compréhension du programme.
— La ligne 3 affiche la valeur de i puis un espace (sans aller à la ligne)
— Les lignes 4, 5 et 6 définissent un int nommé j , recopie la valeur de i, soit 2,
dans j , puis mémorise 1 dans i. Notez bien que i et j sont bien deux variables
différentes : i passe à 1 mais j reste à 2 !
— La ligne 8 nous montre comment définir simultanément plusieurs variables du
même type.
— La ligne 9 nous apprend que l’on peut affecter des variables simultanément à une
même valeur.
— A la ligne 12, des variables sont définies et affectées en même temps. En fait,
on parle plutôt de variables initialisées : elles prennent une valeur initiale en
même temps qu’elles sont définies. Notez que, pour des raisons d’efficacité, les
variables ne sont pas initialisées par défaut : tant qu’on ne leur a pas affecté une
valeur et si elles n’ont pas été initialisées, elles valent n’importe quoi 9 !
— Attention toutefois, il est inutile de tenter une initialisation simultanée. C’est in-
terdit. La ligne 14 provoque une erreur.
— Enfin, on peut rajouter const devant le type d’une variable : celle-ci devient alors
constante et on ne peut modifier son contenu. La ligne 15 définit une telle variable
et la ligne 16 est une erreur.
En résumé, une fois les lignes 14 et 16 supprimées, ce (passionnant !) programme af-
fiche 10 :
2 1 2 3 3 4 5 5 2147483647
Les noms de variable sont composés uniquement des caractères a à z (et majus-
cules), chiffres et underscore _ (évitez celui-ci, il n’est pas très esthétique), mais ne
peuvent pas commencer par un chiffre. N’utilisez pas de caractères accentués, car cela
pose des problèmes de portabilité.
Portée
Dans l’exemple précédent, les variables ont été définies au fur et à mesure des be-
soins. Ce n’est pas une évidence. Par exemple, le C ne permettait de définir les variables
que toutes d’un coup au début du main(). En C++, on peut définir les variables en cours
de route, ce qui permet davantage de clarté. Mais attention :
8. Le nom d’une variable est aussi appelé identificateur. Les messages d’erreur du compilateur utilise-
ront plutôt ce vocabulaire !
9. Ainsi, un entier ne vaut pas 0 lorsqu’il est créé et les octets où il est mémorisé gardent la valeur qu’il
avaient avant d’être réquisitionnés pour stocker l’entier en question. C’est une mauvaise idée d’utiliser
la valeur d’une variable qui vaut n’importe quoi et un compilateur émettra généralement un warning si
on utilise une variable avant de lui fournir une valeur !
10. du moins sur une machine 32 bits, cf. remarque précédente sur INT_MAX
33
les variables "n’existent" (et ne sont donc utilisables) qu’à partir de la ligne
où elles sont définies. Elles ont une durée de vie limitée et meurent dès que
l’on sort du bloc limité par des accolades auquel elles appartiennent a . C’est
ce qu’on appelle la portée d’une variable.
a. C’est un peu plus compliqué pour les variables globales. Nous verrons ça aussi. . .
Ainsi, en prenant un peu d’avance sur la syntaxe des tests, que nous allons voir tout
de suite, le programme suivant provoque des erreurs de portée aux lignes 2 et 8 :
int i ;
i= j ; / / Erreur : j n ’ e x i s t e pas encore !
i n t j =2;
i f ( j >1) {
i n t k=3;
j =k ;
}
i =k ; / / E r r e u r : k n ’ e x i s t e p l u s .
Autres types
Nous verrons les différents types au fur et à mesure. Voici malgré tout les plus
courants :
i n t i =3; // Entier r e l a t i f
double x = 1 2 . 3 ; // Nombre r é e l ( d o u b l e p r é c i s i o n )
char c= ’A ’ ; // Caractère
s t r i n g s= " hop " ; // Chaîne de c a r a c t è r e s
bool t = t r u e ; // B o o l é e n ( v r a i ou f a u x )
Les nombres réels sont en général approchés par des variables de type double ("double
précision", ici sur 8 octets). Les caractères sont représentés par un entier sur un oc-
tet (sur certaines machines de -128 à 127, sur d’autres de 0 à 255), la correspondance
caractère/entier étant celle du code ASCII (65 pour A, 66 pour B, etc.), qu’il n’est heu-
reusement pas besoin de connaître puisque la syntaxe ’A’ entre simples guillemets est
traduite en 65 par le compilateur, etc. Les doubles guillemets sont eux réservés aux
"chaînes" de caractères 11 . Enfin, les booléens sont des variables qui valent vrai (true)
ou faux ( false ).
Voici, pour information, quelques types supplémentaires :

f l o a t y=1.2 f ; // Nombre r é e l simple précision
unsigned i n t j = 4 ; // Entier naturel
signed char d= −128; // Entier r e l a t i f un o c t e t
unsigned char d = 2 5 4 ; // Entier n a t u r e l un o c t e t
complex<double > z ( 2 , 3 ) ; // Nombre complexe
où l’on trouve :
— les float , nombres réels moins précis mais plus courts que les double, ici sur 4
octets (Les curieux pourront explorer la documentation du langage et voir que les
11. Attention, l’utilisation des string nécessite un #include<string> au début du programme.
34
float valent au plus FLT_MAX (ici, environ 3.4e+38 12 ) et que leur valeur la plus
petite strictement positive est FLT_MIN (ici, environ 1.2e−38), de même que pour
les double les constantes DBL_MAX et DBL_MIN valent ici environ 1.8e+308 et
2.2e−308),
— les unsigned int, entiers positifs utilisés pour aller plus loin que les int dans les
positifs (de 0 à UINT_MAX, soit 4294967295 dans notre cas),
— les unsigned char, qui vont de 0 à 255,
— les signed char, qui vont de -128 à 127,
— et enfin les nombres complexes 13 .
3.1.2 Tests
Tests simples
Les tests servent à exécuter telle ou telle instruction en fonction de la valeur d’une
ou de plusieurs variables. Ils sont toujours entre parenthèses. Le “et” s’écrit &&, le
“ou” ||, la négation !, l’égalité ==, la non-égalité !=, et les inégalités >, >=, < et <=.
Si plusieurs instructions doivent être exécutées quand un test est vrai ( if ) ou faux
(else), on utilise des accolades pour les regrouper. Tout cela se comprend facilement
sur l’exemple suivant :
i f ( i ==0) / / i e s t − i l n u l ?
cout << " i e s t nul " << endl ;
...
i f ( i >2) / / i e s t − i l p l u s g r a n d que 2?
j =3;
else
j =5; / / S i on e s t i c i , c ’ e s t que i <=2
...
/ / Cas p l u s c o m p l i q u é !
i f ( i ! = 3 || ( j ==2 && k ! = 3 ) || ! ( i > j && i >k ) ) {
/ / I c i , i e s t d i f f é r e n t d e 3 ou a l o r s
/ / j v a u t 2 e t k e s t d i f f é r e n t d e 3 ou a l o r s
/ / on n ’ a p a s i p l u s g r a n d a l a f o i s d e j e t d e k
cout << " Une première i n s t r u c t i o n " << endl ;
cout << " Une deuxième i n s t r u c t i o n " << endl ;
}
Les variables de type booléen servent à mémoriser le résultat d’un test :
bool t = ( ( i ==3)||( j = = 4 ) ) ;
if ( t )
k=5;
12. Coin des collégiens : 1038 ou 1e+38 vaut 1 suivi de 38 zéros, 10−38 ou 1e−38 vaut 0.000 . . . 01 avec
37 zéros avant le 1. En compliquant : 3.4e+38 vaut 34 suivis de 37 zéros (38 chiffres après le 3) et 1.2e−38
vaut 0.00 . . . 012 toujours avec 37 zéros entre la virgule et le 1 (le 1 est à la place 38).
13. Il est trop tôt pour comprendre la syntaxe "objet" de cette définition mais il nous parait important
de mentionner dès maintenant que les complexes existent en C++.
Coin des collégiens : pas de panique ! Vous apprendrez ce que sont les nombres complexes plus tard.
Ils ne seront pas utilisés dans ce livre.
35
Enfin, une dernière chose très importante : penser à utiliser == et non = sous peine
d’avoir des surprises. 14 C’est peut-être l’erreur la plus fréquente chez les débutants.
Elle est heureusement signalée aujourd’hui par un warning. . .
Attention : utiliser if ( i==3) et non if ( i=3) !
Le "switch"
On a parfois besoin de faire telle ou telle chose en fonction des valeurs possibles
d’une variable. On utilise alors souvent l’instruction switch pour des raisons de clarté
de présentation. Chaque cas possible pour les valeurs de la variable est précisé avec
case et doit se terminer par break 15 . Plusieurs case peuvent être utilisés pour préciser
un cas multiple. Enfin, le mot clé default, à placer en dernier, correspond aux cas non
précisés. Le programme suivant 16 réagit aux touches tapées au clavier et utilise un
switch pour afficher des commentaires passionnants !
1 # i n c l u d e <iostream >
2 using namespace s t d ;
3 # i n c l u d e <conio . h> / / Non s t a n d a r d !
4
5 i n t main ( )
6 {
7 bool f i n i = f a l s e ;
8 char c ;
9 do {
10 c=_ g e t c h ( ) ; / / Non s t a n d a r d !
11 s w i tch ( c ) {
12 case ’ a ’ :
13 cout << " Vous avez tapé ’ a ’ ! " << endl ;
14 break ;
15 case ’ f ’ :
16 cout << " Vous avez tapé ’ f ’ . Au r e v o i r ! " << endl ;
17 f i n i =true ;
18 break ;
19 case ’ e ’ :
20 case ’ i ’ :
21 case ’o ’ :
22 case ’u ’ :
23 case ’y ’ :
24 cout << " Vous avez tapé une a u t r e v o y e l l e ! " << endl ;
14. Faire if ( i=3) affecte 3 à i puis renvoie 3 comme résultat du test, ce qui est considéré comme vrai
car la convention est qu’un booléen est en fait un entier, faux s’il est nul et vrai s’il est non nul !
15. C’est une erreur grave et fréquente d’oublier le break. Sans lui, le programme exécute aussi les
instructions du cas suivant !
16. Attention, un cin >> c, instruction que nous verrons plus loin, lit bien un caractère au clavier
mais ne réagit pas à chaque touche : il attend qu’on appuie sur la touche Entrée pour lire d’un coup
toutes les touches frappées ! Récupérer juste une touche à la console n’est malheureusement pas stan-
dard et n’est plus très utilisé dans notre monde d’interfaces graphiques. Sous Windows, il faudra utiliser
_getch() après avoir fait un #include <conio.h> (cf. lignes 3 et 10) et sous Unix getch() après avoir fait
un #include <curses.h>.
36
25 break ;
26 default :
27 cout << " Vous avez tapé a u t r e chose ! " << endl ;
28 break ;
29 }
30 } while ( ! f i n i ) ;
31 return 0;
32 }
Si vous avez tout compris, le switch précédant ceci est équivalent à 17 :
i f ( c== ’ a ’ )
cout << " Vous avez tapé ’ a ’ ! " << endl ;
e l s e i f ( c== ’ f ’ ) {
cout << " Vous avez tapé ’ f ’ . Au r e v o i r ! " << endl ;
f i n i =true ;
} e l s e i f ( c== ’ e ’ || c== ’ i ’ || c== ’ o ’ || c== ’ u ’ || c== ’ y ’ )
cout << " Vous avez tapé une a u t r e v o y e l l e ! " << endl ;
else
cout << " Vous avez tapé a u t r e chose ! " << endl ;
Avant tout, rappelons la principale source d’erreur du switch :
Dans un switch, ne pas oublier les break !
Vous avez pu remarquer cette ligne 2 un peu cryptique. Un namespace est un pré-
fixe pour certains objets. Le préfixe des objets standard du langage est std. Ainsi cout
et endl ont pour nom complet std :: cout et std :: endl. La ligne 2 permet d’omettre ce
préfixe.
3.1.3 Boucles
Il est difficile de faire un programme qui fait quelque chose sans avoir la possibilité
d’exécuter plusieurs fois la même instruction. C’est le rôle des boucles. La plus utili-
sée est le for () , mais ça n’est pas la plus simple à comprendre. Commençons par le
do ... while, qui "tourne en rond" tant qu’un test est vrai. Le programme suivant at-
tend que l’utilisateur tape au clavier un entier entre 1 et 10, et lui réitère sa question
jusqu’à obtenir un nombre correct :
3
4 i n t main ( )
5 {
6 int i ;
7 do { / / Début d e l a b o u c l e
8 cout << "Un nombre e n t r e 1 e t 1 0 , SVP : " ;
17. On voit bien que le switch n’est pas toujours plus clair ni plus court. C’est comme tout, il faut
l’utiliser à bon escient. . . Et plus nous connaîtrons de C++, plus nous devrons nous rappeler cette règle
et éviter de faire des fonctions pour tout, des structures de données pour tout, des objets pour tout, des
fichiers séparés pour tout, etc.
37
9 c i n >> i ;
10 } while ( i <1 || i > 1 0 ) ; / / R e t o u r n e au d é b u t d e l a b o u c l e s i
11 / / ce t e s t est vrai
12 cout << " Merci ! Vous avez tapé " << i << endl ;
13 return 0;
14 }
Notez la ligne 9 qui met dans i un nombre tapé au clavier. La variable cin est le pendant
en entrée ("console in") de la sortie cout.
Vient ensuite le while qui vérifie le test au début de la boucle. Le programme sui-
vant affiche les entiers de 1 à 100 :
i n t i =1;
while ( i <=100) {
cout << i << endl ;
i = i +1;
}
Enfin, on a crée une boucle spéciale tant elle est fréquente : le for () qui exécute
une instruction avant de démarrer, effectue un test au début de chaque tour, comme le
while, et exécute une instruction à la fin de chaque boucle. Instruction initiale, test et
instruction finale sont séparées par un ;, ce qui donne le programme suivant, absolu-
ment équivalent au précédent :
int i ;
f o r ( i = 1 ; i <=100; i = i +1) {
cout << i << endl ;
}
En général, le for () est utilisé comme dans l’exemple précédent pour effectuer une
boucle avec une variable (un indice) qui prend une série de valeurs dans un certain
intervalle. On trouvera en fait plutôt :
f o r ( i n t i = 1 ; i <=100; i ++)
cout << i << endl ;
quand on sait que :
— On peut définir la variable dans la première partie du for () . Attention, cette va-
riable admet le for () pour portée : elle n’est plus utilisable en dehors du for () 18 .
— i++ est une abbréviation de i=i+1
— Puisqu’il n’y a ici qu’une seule instruction dans la boucle, les accolades étaient
inutiles.
On utilise aussi la virgule , pour mettre plusieurs instructions 19 dans l’instruction fi-
nale du for. Ainsi, le programme suivant part de i=1 et j=100, et augmente i de 2 et
diminue j de 3 à chaque tour jusqu’à ce que leurs valeurs se croisent 20 :
18. Les vieux C++ ne permettaient pas de définir la variable dans la première partie du for () . Des C++
un peu moins anciens permettaient de le faire mais la variable survivait au for () !
19. Pour les curieux : ça n’a en fait rien d’extraordinaire, car plusieurs instructions séparées par une
virgule deviennent en C++ une seule instruction qui consiste à exécuter l’une après l’autre les différentes
instructions ainsi rassemblées.
20. Toujours pour les curieux, il s’arrête pour i=39 et j=43.
38
f o r ( i n t i =1 , j = 1 0 0 ; j > i ; i = i +2 , j = j −3)
cout << i << " " << j << endl ;
Notez aussi qu’on peut abréger i=i+2 en i+=2 et j =j−3 en j −=3.
3.1.4 Récréations
Nous pouvons déjà faire de nombreux programmes. Par exemple, jouer au juste
prix. Le programme choisit le prix, et l’utilisateur devine :
2 # include <cstdlib >
4
5 i n t main ( )
6 {
7 i n t n=rand ( ) % 1 0 0 ; / / nombre à d e v i n e r e n t r e 0 e t 99
8 int i ;
9 do {
10 cout << " Votre p r i x : " ;
11 c i n >> i ;
12 i f ( i >n )
13 cout << "C ’ e s t moins " << endl ;
14 e l s e i f ( i <n )
15 cout << "C ’ e s t plus " << endl ;
16 else
17 cout << " Gagne ! " << endl ;
18 } while ( i ! = n ) ;
19 return 0;
20 }
Seule la ligne 7 a besoin d’explications :
— la fonction rand() fournit un nombre entier au hasard entre 0 et RAND_MAX. On
a besoin de rajouter #include <cstdlib> pour l’utiliser
— % est la fonction modulo 21 .
C’est évidemment plus intéressant quand c’est le programme qui devine. Pour cela,
il va procéder par dichotomie, afin de trouver au plus vite :
3
4 i n t main ( )
5 {
6 cout << " C h o i s i s s e z un nombre e n t r e 1 e t 100 " << endl ;
7 cout << " Repondez par + , − ou = " << endl ;
8 i n t a =1 , b = 1 0 0 ; / / V a l e u r s e x t r è m e s
21. Coin des collégiens : compter "modulo N", c’est retomber à 0 quand on atteint N. Modulo 4, cela
donne : 0,1,2,3,0,1,2,3,0,. . . . Par exemple 12%10 vaut 2 et 11%3 aussi ! Ici, le modulo 100 sert à retomber
entre 0 et 99.
39
9 bool trouve= f a l s e ;
10 do {
11 i n t c =( a+b ) / 2 ; / / On p r o p o s e l e m i l i e u
12 cout << " S e r a i t −ce " << c << " ? : " ;
13 char r ;
14 do
15 c i n >> r ;
16 while ( r ! = ’ = ’ && r ! = ’ + ’ && r ! = ’− ’ ) ;
17 i f ( r== ’ = ’ )
18 trouve= t r u e ;
19 e l s e i f ( r== ’− ’ )
20 b=c −1; / / C ’ e s t moins , on e s s a i e e n t r e a e t c −1
21 else
22 a=c + 1 ; / / C ’ e s t p l u s , on e s s a i e e n t r e c +1 e t b
23 } while ( ! trouve && ( a<=b ) ) ;
24 i f ( trouve )
25 cout << " Quel boss j e s u i s ! " << endl ;
26 else
27 cout << " Vous avez t r i c h é ! " << endl ;
28 return 0;
29 }
On peut aussi compléter le programme "supplémentaire" du TP de l’annexe A.1. Il

s’agissait d’une balle rebondissant dans un carré. (Voir l’annexe B pour les instructions
graphiques. . . )
1 # i n c l u d e <Imagine/Graphics . h>
2 using namespace Imagine ;
3
4 i n t main ( )
5 {
6 i n t w=300 , h = 2 1 0 ;
7 openWindow (w, h ) ; / / F e n ê t r e g r a p h i q u e
8 i n t i =0 , j = 0 ; // Position
9 i n t di =2 , d j = 3 ; // Vitesse
10 while ( t r u e ) {
11 f i l l R e c t ( i , j , 4 , 4 ,RED ) ; / / D e s s i n d e l a b a l l e
12 m i l l i S l e e p ( 1 0 ) ; / / On a t t e n d un peu . . .
13 i f ( i +di >w || i +di <0) {
14 di=−di ; / / Rebond h o r i z o n t a l s i on s o r t
15 }
16 i n t n i = i +di ; / / N o u v e l l e p o s i t i o n
17 i f ( j +dj >h || j +dj <0) {
18 d j=−d j ; / / Rebond v e r t i c a l s i on s o r t
19 }
20 int nj= j +dj ;
21 f i l l R e c t ( i , j , 4 , 4 ,WHITE ) ; / / E f f a c e m e n t
22 i = n i ; / / On c h a n g e d e p o s i t i o n
23 j =nj ;
40
3. Premiers programmes 3.2. Fonctions
24 }
25 endGraphics ( ) ;
26 return 0;
27 }
Notez ce endGraphics() dont la fonction est d’attendre un clic de l’utilisateur avant
de terminer le programme, de manière à laisser la fenêtre visible le temps nécessaire.
Cette fonction n’est pas standard, et elle est dans le namespace Imagine. La ligne 2
permet de l’appeler sans utiliser son nom complet Imagine::endGraphics(). Les autres
fonctions appelées dans ce petit programme (openWindow, fillRect et milliSleep) sont
aussi fournies par Imagine.
3.2 Fonctions
Lorsqu’on met tout dans le main() on réalise très vite que l’on fait souvent des
copier/coller de bouts de programmes. Si des lignes de programmes commencent à se
ressembler, c’est qu’on est vraisemblablement devant l’occasion de faire des fonctions.
On le fait pour des raisons de clarté, mais aussi pour faire des économies de frappe au
clavier !
Il faut regrouper les passages identiques en fonctions :

— pour obtenir un programme clair. . .
— et pour moins se fatiguer !
Attention à bien comprendre quand faire une fonction et à ne pas simple-
ment découper un programme en petits morceaux sans aucune logique a .
a. ou juste pour faire plaisir au professeur. Mal découper un programme est la meilleure
façon de ne plus avoir envie de le faire la fois suivante. Encore une fois, le bon critère est ici
que la bonne solution est généralement la moins fatiguante.
En fait, pouvoir réutiliser le travail déjà fait est le fil conducteur d’une bonne program-
mation. Pour l’instant, nous nous contentons, grâce aux fonctions, de réutiliser ce que
nous venons de taper quelques lignes plus haut. Plus tard, nous aurons envie de réuti-
liser ce qui aura été fait dans d’autres programmes, ou longtemps auparavant, ou dans
les programmes d’autres personnes, et nous verrons alors comment faire.
Prenons le programme suivant, qui dessine des traits et des cercles au hasard, et
dont la figure 3.1 montre un résultat :
5
6 i n t main ( )
7 {
8 openWindow ( 3 0 0 , 2 0 0 ) ;
9 f o r ( i n t i = 0 ; i < 1 5 0 ; i ++) {
10 i n t x1=rand ( ) % 3 0 0 ; / / P o i n t i n i t i a l
11 i n t y1=rand ( ) % 2 0 0 ;
41
3.2. Fonctions 3. Premiers programmes
F IGURE 3.1 – Traits et cercles au hasard. . .
12 i n t x2=rand ( ) % 3 0 0 ; / / P o i n t f i n a l
13 i n t y2=rand ( ) % 2 0 0 ;
14 Color c=Color ( rand ( ) % 2 5 6 , rand ( ) % 2 5 6 , rand ( ) % 2 5 6 ) ; / / RVB
15 drawLine ( x1 , y1 , x2 , y2 , c ) ; / / T r a c é d e s e g m e n t
16 i n t xc=rand ( ) % 3 0 0 ; / / C e n t r e du c e r c l e
17 i n t yc=rand ( ) % 2 0 0 ;
18 i n t r c =rand ( ) % 1 0 ; / / Rayon
19 Color c c =Color ( rand ( ) % 2 5 6 , rand ( ) % 2 5 6 , rand ( ) % 2 5 6 ) ; / / RVB
20 f i l l C i r c l e ( xc , yc , rc , c c ) ; / / C e r c l e
21 }
23 return 0;
24 }
La première chose qui choque 22 , c’est l’appel répété à rand() et à modulo pour tirer
un nombre au hasard. On aura souvent besoin de tirer des nombres au hasard dans
un certain intervalle et il est naturel de le faire avec une fonction. Au passage, nous
corrigeons une deuxième chose qui choque : les entiers 300 et 200 reviennent souvent.
Si nous voulons changer les dimensions de la fenêtre, il faudra remplacer dans le pro-
gramme tous les 300 et tous les 200. Il vaudrait mieux mettre ces valeurs dans des
variables et faire dépendre le reste du programme de ces variables. C’est un défaut
constant de tous les débutants et il faut le corriger tout de suite.
Il faut dès le début d’un programme repérer les paramètres constants uti-
lisés à plusieurs reprises et les placer dans des variables dont dépendra le
programme. On gagne alors beaucoup de temps a quand on veut les modi-
fier par la suite.
a. Encore la règle du moindre effort. . . Si on fait trop de copier/coller ou de remplacer avec
l’éditeur, c’est mauvais signe !
22. à part évidemment la syntaxe "objet" des variables de type Color pour lesquelles on se permet un
Color(r,v,b) bien en avance sur ce que nous sommes censés savoir faire. . .
42
Bref, notre programme devient :

/ / Nombre e n t r e 0 e t n−1
i n t hasard ( i n t n )
{
r e t u r n rand ()%n ;
}
i n t main ( )
{
c o n s t i n t w=300 , h = 2 0 0 ;
openWindow (w, h ) ;
f o r ( i n t i = 0 ; i < 1 5 0 ; i ++) {
i n t x1=hasard (w) , y1=hasard ( h ) ; / / P o i n t i n i t i a l
i n t x2=hasard (w) , y2=hasard ( h ) ; / / P o i n t f i n a l
Color c=Color ( hasard ( 2 5 6 ) , hasard ( 2 5 6 ) , hasard ( 2 5 6 ) ) ;
drawLine ( x1 , y1 , x2 , y2 , c ) ; / / T r a c é d e s e g m e n t
i n t xc=hasard (w) , yc=hasard ( h ) ; / / C e n t r e du c e r c l e
i n t r c =hasard (w/ 2 0 ) ; / / Rayon
Color c c =Color ( hasard ( 2 5 6 ) , hasard ( 2 5 6 ) , hasard ( 2 5 6 ) ) ;
f i l l C i r c l e ( xc , yc , rc , c c ) ; / / C e r c l e
}
endGraphics ( ) ;
return 0;
}
On pourrait penser que hasard(w) est aussi long à taper que rand()%w et que notre
fonction est inutile. C’est un peu vrai. Mais en pratique, nous n’avons alors plus à
nous souvenir de l’existence de la fonction rand() ni de comment on fait un modulo.
C’est même mieux que ça : nous devenons indépendant de ces deux fonctions, et si
vous voulions tirer des nombres au hasard avec une autre fonction 23 , nous n’aurions
plus qu’à modifier la fonction hasard(). C’est encore une règle importante.
On doit également faire une fonction quand on veut séparer et factoriser

le travail. Il est ensuite plus facile a de modifier la fonction que toutes les
lignes qu’elle a remplacées !
a. Moindre effort, toujours !
3.2.1 Retour
Nous venons de définir sans l’expliquer une fonction hasard() qui prend un para-
mètre n de type int et qui retourne un résultat, de type int lui aussi. Il n’y a pas grand
chose à savoir de plus, si ce n’est que :
23. Pourquoi vouloir le faire ? Dans notre cas parce que la fonction rand() utilisée est suffisante pour
des applications courantes mais pas assez précise pour des applications mathématiques. Par exemple,
faire un modulo ne répartit pas vraiment équitablement les nombres tirés. Enfin, nous avons oublié
d’initialiser le générateur aléatoire. Si vous le permettez, nous verrons une autre fois ce que cela signifie
et comment le faire en modifiant juste la fonction hasard().
43
1. Une fonction peut ne rien renvoyer. Son type de retour est alors void et il n’y a
pas de return à la fin. Par exemple :
void dis_bonjour_a_la_dame ( s t r i n g nom_de_la_dame ) {
cout << " Bonjour , Mme " << nom_de_la_dame << " ! " << endl ;
}
...
dis_bonjour_a_la_dame ( " Germaine " ) ;
dis_bonjour_a_la_dame ( " F i t z g e r a l d " ) ;
2. Une fonction peut comporter plusieurs instructions return 24 . Cela permet de sor-
tir quand on en a envie, ce qui est bien plus clair et plus proche de notre façon de
penser :
i n t s i g n e _ a v e c _ u n _ s e u l _ r e t u r n ( double x ) {
int s ;
i f ( x ==0)
s =0;
e l s e i f ( x <0)
s =−1;
else
s =1;
return s ;
}
i n t s i g n e _ p l u s _ s i m p l e ( double x ) {
i f ( x <0)
r e t u r n −1;
i f ( x >0) / / N o t e z l ’ a b s e n c e d e e l s e , d e v e n u i n u t i l e !
return 1;
return 0;
}
3. Pour une fonction void, on utilise return sans rien derrière pour un retour en
cours de fonction :
void t e l e p h o n e r _ a v e c _ u n _ s e u l _ r e t u r n ( s t r i n g nom) {
i f ( j_ai_le_telephone ) {
i f (mon telephone_marche ) {
i f ( e s t _ d a n s _ l _ a n n u a i r e (nom ) ) {
i n t numero=numero_telephone (nom ) ;
composer ( numero ) ;
i f ( ca_decroche ) {
parler ( ) ;
raccrocher ( ) ;
}
}
}
}
24. Contrairement à certains vieux langages, comme le Pascal
44
}
void t e l e p h o n e r _ p l u s _ s i m p l e ( s t r i n g nom) {
i f ( ! j_ai_le_telephone )
return ;
i f ( ! mon telephone_marche )
return ;
i f ( ! e s t _ d a n s _ l _ a n n u a i r e (nom ) )
return ;
i n t numero=numero_telephone (nom ) ;
composer ( numero ) ;
i f ( ! ca_decroche )
return ;
parler ( ) ;
raccrocher ( ) ;
}
3.2.2 Paramètres
Nous n’avons vu que des fonctions à un seul paramètre. Voici comment faire pour
en passer plusieurs ou n’en passer aucun :
/ / Nombre e n t r e a e t b
i n t hasard2 ( i n t a , i n t b )
{
r e t u r n a +( rand ( ) % ( b−a + 1 ) ) ;
}
/ / Nombre e n t r e 0 e t 1
double hasard3 ( )
{
r e t u r n rand ( ) / double (RAND_MAX) ;
}
...
i n t a=hasard2 ( 1 , 1 0 ) ;
double x=hasard3 ( ) ;
...
Attention à bien utiliser x=hasard3() et non simplement x=hasard3 pour appeler cette
fonction sans paramètre. Ce simple programme est aussi l’occasion de parler d’une
erreur très fréquente : la division de deux nombres entiers donne un nombre entier !
Ainsi, écrire double x=1/3; est une erreur car le C++ commence par calculer 1/3 avec
des entiers, ce qui donne 0, puis convertit 0 en double pour le ranger dans x. Il ne sait
pas au moment de calculer 1/3 qu’on va mettre le résultat dans un double ! Il faut alors faire
en sorte que le 1 ou le 3 soit une double et écrire double x=1.0/3; ou double x=1/3.0;.
Si, comme dans notre cas, on a affaire à deux variables de type int, il suffit de convertir
une de ces variables en double avec la syntaxe double (...) que nous verrons plus tard.
45
1. Fonction sans paramètre : x=hop(); et non x=hop;.

2. Division entière :
— double x=1.0/3; et non double x=1/3;
— double x=double(i)/j; et non double x=i/j;, ni même
double x=double(i/j); a
a. Cette conversion en double arrive trop tard !
3.2.3 Passage par référence

Lorsqu’une fonction modifie la valeur d’un de ses paramètres, et si ce paramètre
était une variable dans la fonction appelante, alors la variable en question n’est pas
modifiée. Plus clairement, le programme suivant échoue :
void t r i p l e ( i n t x ) {
x=x ∗ 3 ;
}
...
i n t a =2;
triple (a );
cout << a << endl ;
Il affiche 2 et non 6. En fait, le paramètre x de la fonction triple vaut bien 2, puis 6.
Mais son passage à 6 ne modifie pas a. Nous verrons plus loin que x est mémorisé
à un endroit différent de a, ce qui explique tout ! C’est la valeur de a qui est passée
à la fonction triple () et non pas la variable a ! On parle de passage par valeur. On
peut toutefois faire en sorte que la fonction puisse vraiment modifier son paramètre.
On s’agit alors d’un passage par référence (ou par variable). Il suffit de rajouter un &
derrière le type du paramètre :
void t r i p l e ( i n t& x ) {
x=x ∗ 3 ;
}
Généralement, on choisit l’exemple suivant pour justifier le besoin des références :
void echanger1 ( i n t x , i n t y ) {
i n t t =x ;
x=y ;
y= t ;
}
void echanger2 ( i n t& x , i n t& y ) {
i n t t =x ;
x=y ;
y= t ;
}
...
i n t a =2 , b = 3 ;
echanger1 ( a , b ) ;
cout << a << " " << b << " " ;
46
echanger2 ( a , b ) ;
cout << a << " " << b << endl ;
...
Ce programme affiche 2 3 3 2, echanger1() ne marchant pas.
Une bonne façon de comprendre le passage par référence est de considérer que les
variables x et y de echanger1 sont des variables vraiment indépendantes du a et du
b de la fonction appelante, alors qu’au moment de l’appel à echanger2, le x et le y
de echanger2 deviennent des "liens" avec a et b. A chaque fois que l’on utilise x dans
echanger2, c’est en fait a qui est utilisée. Pour encore mieux comprendre allez voir le
premier exercice du TP 2 (A.2.1) et sa solution.
En pratique,
on utilise aussi les références pour faire des fonctions retournant plusieurs
valeurs à la fois,
et ce, de la façon suivante :

void un_point ( i n t& x , i n t& y ) {
x=...;
y=...;
}
...
int a , b ;
un_point ( a , b ) ;
Ainsi, notre programme de dessin aléatoire deviendrait :
5
6 / / Nombre e n t r e 0 e t n−1
7 i n t hasard ( i n t n )
8 {
9 r e t u r n rand ()%n ;
10 }
11
12 Color une_couleur ( ) {
13 r e t u r n Color ( hasard ( 2 5 6 ) , hasard ( 2 5 6 ) , hasard ( 2 5 6 ) ) ;
14 }
15
16 void un_point ( i n t w, i n t h , i n t& x , i n t& y ) {
17 x=hasard (w) ;
18 y=hasard ( h ) ;
19 }
20
21 i n t main ( )
22 {
23 c o n s t i n t w=300 , h = 2 0 0 ;
47
24 openWindow (w, h ) ;
25 f o r ( i n t i = 0 ; i < 1 5 0 ; i ++) {
26 i n t x1 , y1 ; / / P o i n t i n i t i a l
27 un_point (w, h , x1 , y1 ) ;
28 i n t x2 , y2 ; / / P o i n t f i n a l
29 un_point (w, h , x2 , y2 ) ;
30 Color c=une_couleur ( ) ;
31 drawLine ( x1 , y1 , x2 , y2 , c ) ; / / T r a c é d e s e g m e n t
32 i n t xc , yc ; / / C e n t r e du c e r c l e
33 un_point (w, h , xc , yc ) ;
34 i n t r c =hasard (w/ 2 0 ) ; / / Rayon
35 Color c c =une_couleur ( ) ;
36 f i l l C i r c l e ( xc , yc , rc , c c ) ; / / C e r c l e
37 }
39 return 0;
40 }
Avec le conseil suivant :
penser à utiliser directement le résultat d’une fonction et ne pas le mémori-

ser dans une variable lorsque c’est inutile.
Il devient même :
26 i n t x1 , y1 ; / / P o i n t i n i t i a l
27 un_point (w, h , x1 , y1 ) ;
28 i n t x2 , y2 ; / / P o i n t f i n a l
29 un_point (w, h , x2 , y2 ) ;
30 drawLine ( x1 , y1 , x2 , y2 , une_couleur ( ) ) ; / / T r a c é d e s e g m e n t
31 i n t xc , yc ; / / C e n t r e du c e r c l e
32 un_point (w, h , xc , yc ) ;
33 i n t r c =hasard (w/ 2 0 ) ; / / Rayon
34 f i l l C i r c l e ( xc , yc , rc , une_couleur ( ) ) ; / / C e r c l e
3.2.4 Portée, Déclaration, Définition

Depuis le début, nous créons des fonctions en les définissant. Il est parfois utile de
ne connaître que le type de retour et les paramètres d’une fonction sans pour autant
savoir comment elle est programmée, c’est-à-dire sans connaître le corps de la fonction.
Une des raisons de ce besoin est que :
comme les variables, les fonctions ont une portée et ne sont connues que
dans les lignes de source qui lui succèdent.
Ainsi, le programme suivant ne compile pas :

1 i n t main ( )
2 {
3 f ();
48
4 return 0;
5 }
6 void f ( ) {
7 }
car à la ligne 3, f () n’est pas connue. Il suffit ici de mettre les lignes 6 et 7 avant le main()
pour que le programme compile. Par contre, il est plus difficile de faire compiler :
void f ( )
{
g ( ) ; / / Erreur : g ( ) inconnue
}
void g ( ) {
f ();
}
puisque les deux fonctions on besoin l’une de l’autre, et qu’aucun ordre ne conviendra.
Il faut alors connaître la règle suivante :
— Remplacer le corps d’une fonction par un ; s’appelle déclarer la fonc-

tion.
— Déclarer une fonction suffit au compilateur, qui peut "patienter" a jus-
qu’à sa définition.
a. En réalité, le compilateur n’a besoin que de la déclaration. C’est le linker qui devra trou-
ver quelque part la définition de la fonction, ou plus exactement le résultat de la compilation
de sa définition !
Notre programme précédent peut donc se compiler avec une ligne de plus :
void g ( ) ; / / D é c l a r a t i o n de g
void f ( )
{
g(); / / OK: f o n c t i o n d é c l a r é e
}
void g ( ) { / / D é f i n i t i o n d e g
f ();
}
3.2.5 Variables locales et globales

Nous avons vu section 3.1.1 la portée des variables. La règle des accolades s’ap-
plique évidemment aux accolades du corps d’une fonction.
Les variables d’une fonction sont donc inconnues en dehors de la fonction
On parle alors de variables locales à la fonction. Ainsi, le programme suivant est in-
terdit :
49
void f ( )
{
int x ;
x =3;
}
void g ( ) {
int y ;
y=x ; / / E r r e u r : x i n c o n n u
}
Si vraiment deux fonctions utilisent des variables communes, il faut alors les "sortir"
des fonctions. Elles deviennent alors des variables globales, dont voici un exemple :
1 int z ; / / globale
2
3 void f ( )
4 {
5 int x ; / / loc ale
6 ...
7 i f ( x<z )
8 ...
9 }
10
11 void g ( )
12 {
13 int y ; / / loc ale
14 ...
15 z=y ;
16 ...
17 }
L’utilisation de variables globales est tolérée et parfois justifiée. Mais elle constitue une
solution de facilité dont les débutants abusent et il faut combattre cette tentation dès le
début :
les variables globales sont à éviter au maximum car
— elles permettent parfois des communications abusives entre fonctions,
sources de bugs a .
— les fonctions qui les utilisent sont souvent peu réutilisables dans des
contextes différents.
En général, elles sont le signe d’une mauvaise façon de traiter le problème.
a. C’est pourquoi les variables globales non constantes ne sont pas tolérées chez le débu-
tant. Voir le programme précédent où g() parle à f () au travers de z.
3.2.6 Surcharge
Il est parfois utile d’avoir une fonction qui fait des choses différentes suivant le type
d’argument qu’on lui passe. Pour cela on peut utiliser la surcharge :
50
3. Premiers programmes 3.3. TP
F IGURE 3.2 – Mini tennis. . .
Deux fonctions qui ont des listes de paramètres différentes peuvent avoir le
même nom a . Attention : deux fonctions aux types de retour différents mais
aux paramètres identiques ne peuvent avoir le même nom b .
a. Car alors la façon de les appeler permettra au compilateur de savoir laquelle des fonc-
tions on veut utiliser
b. Car alors le compilateur ne pourra différencier leurs appels.
Ainsi, nos fonctions "hasard" de tout à l’heure peuvent très bien s’écrire :
1 / / Nombre e n t r e 0 e t n−1
2 i n t hasard ( i n t n ) {
3 r e t u r n rand ()%n ;
4 }
5 / / Nombre e n t r e a e t b
6 i n t hasard ( i n t a , i n t b ) {
7 r e t u r n a +( rand ( ) % ( b−a + 1 ) ) ;
8 }
9 / / Nombre e n t r e 0 e t 1
10 double hasard ( ) {
11 r e t u r n rand ( ) / double (RAND_MAX) ;
12 }
13 ...
14 i n t i =hasard ( 3 ) ; // entre 0 et 2
15 i n t j =hasard ( 2 , 4 ) / / e n t r e 2 e t 4
16 double k=hasard ( ) ; / / e n t r e 0 e t 1
3.3 TP
Nous pouvons maintenant aller faire le deuxième TP donné en annexe A.2 afin de
mieux comprendre les fonctions et aussi pour obtenir un mini jeu de tennis (figure 3.2).
51
3.4. Fiche de référence 3. Premiers programmes
3.4 Fiche de référence

Variables — Négation : ! — Déclaration :
— Définition : — Combinaisons : && || int plus(int a,int b);
int i; — if (i==0) j=1; — Retour :
int k,l,m; — if (i==0) j=1; int signe(double x) {
— Affectation : else j=2; if (x<0)
i=2; return -1;
j=i; — if (i==0) { if (x>0)
k=l=3; j=1; return 1;
k=2; return 0;
— Initialisation : }
int n=5,o=n; }
void afficher(int x,
— Constantes : — bool t=(i==0); int y) {
const int s=12; if (t) if (x<0 || y<0)
j=1; return;
— Portée :
— switch (i) { if (x>=w || y>=h)
int i;
case 1: return;
// i=j; interdit!
...; DrawPoint(x,y,RED);
int j=2;
...; }
i=j; // OK!
break;
if (j>1) { — Appel :
case 2:
int k=3; int f(int a) { ... }
case 3:
j=k; // OK! int g() { ... }
...;
} ...
break;
//i=k; interdit! int i=f(2),j=g();
default:
— Types : ...; — Références :
int i=3; } void swap(int& a,
double x=12.3; int& b){
char c=’A’; Boucles int tmp=a;
string s="hop"; — do { a=b;b=tmp;
bool t=true; ... }
float y=1.2f; } while(!ok); ...
unsigned int j=4; — int i=1; int x=3,y=2;
signed char d=-128; while(i<=100) { swap(x,y);
unsigned char d=25; ... — Surcharge :
complex<double> i=i+1; int hasard(int n);
z(2,3); } int hasard(int a,
— for(int i=1;i<=10;i++) int b);
— Variables globales : ... double hasard();
int n; — for(int i=1,j=10;j>i;
const int m=12; i=i+2,j=j-3) Divers
void f() { ... — i++;
n=10; // OK i--;
int i=m; // OK Fonctions
i-=2;
... — Définition : j+=3;
— Conversion : int plus(int a,int b){
int c=a+b; — j=i%n; // Modulo
int i=int(x),j;
float x=float(i)/j; return c; — #include <cstdlib>
} ...
Tests void affiche(int a) { i=rand()%n;
— Comparaison : cout << a << endl; x=rand()/
== != < > <= >= } double(RAND_MAX);
52
3. Premiers programmes 3.4. Fiche de référence

Entrées/Sorties — for(int i=0,i<100,i++) — Step over : F10
— #include <iostream> // NON!
— Step inside : F11
using namespace std; — int f() {...}
... int i=f; // NON! — Indent : Ctrl+A,Ctrl+I
cout <<"I="<<i<<endl; — double x=1/3; // NON! Conseils
cin >> i >> j; int i,j;
Erreurs fréquentes x=i/j; // NON! — Nettoyer en quittant.
— Pas de définition de fonction x=double(i/j); //NON! — Erreurs et warnings : cliquer.
dans une fonction ! — Indenter.
Imagine++
— int q=r=4; // NON!
— Voir documentation. . . — Ne pas laisser de warning.
— if (i=2) // NON!
if i==2 // NON! Clavier — Utiliser le debuggeur.
if (i==2) then // NON! — Debug : F5 — Faire des fonctions.
53
4. Les tableaux
Chapitre 4
Les tableaux
Tout en continuant à utiliser les fonctions pour les assimiler, nous allons rajouter les ta-
bleaux qui, sinon, nous manqueraient rapidement. Nous n’irons pas trop vite et ne verrons
pour l’instant que les tableaux à une dimension et de taille fixe. Nous étudierons dans un autre
chapitre les tableaux de taille variable et les questions de mémoire ("pile" et "tas").
4.1 Premiers tableaux

De même qu’on a tout de suite ressenti le besoin d’avoir des boucles pour faire
plusieurs fois de suite la même chose, il a été rapidement utile de faire plusieurs fois
la même chose mais sur des variables différentes. D’où les tableaux. . . Ainsi, le pro-
gramme suivant :
i n t x1 , y1 , u1 , v1 ; / / B a l l e 1
i n t x2 , y2 , u2 , v2 ; / / B a l l e 2
i n t x3 , y3 , u3 , v3 ; / / B a l l e 3
i n t x4 , y4 , u4 , v4 ; / / B a l l e 4
...
BougeBalle ( x1 , y1 , u1 , v1 ) ;
pourra avantageusement être remplacé par :
int x [4] ,y[4] ,u[4] ,v [ 4 ] ; / / Balles
...
f o r ( i n t i = 0 ; i < 4 ; i ++)
BougeBalle ( x [ i ] , y [ i ] , u [ i ] , v [ i ] ) ;
dans lequel int x[4] définit un tableau de 4 variables de type int : x[0], x[1], x[2] et
x[3]. En pratique, le compilateur réserve quelque part en mémoire de quoi stocker les
4 variables en question et gère de quoi faire en sorte que x[ i ] désigne la bonne variable.
Un autre exemple pour mieux comprendre, qui additionne des double deux par
deux en mémorisant les résultats :
4.1. Premiers tableaux 4. Les tableaux
double x [ 1 0 0 ] , y [ 1 0 0 ] , z [ 1 0 0 ] ;
...
. . . / / i c i , l e s x [ i ] et y [ i ] prennent des valeurs
...
f o r ( i n t i = 0 ; i < 1 0 0 ; i ++)
z [ i ]= x [ i ]+ y [ i ] ;
...
. . . / / i c i , on u t i l i s e l e s z [ i ]
...
Il y deux choses essentielles à retenir.
1. D’abord :
les indices d’un tableau t de taille n vont de 0 à n-1. Tout accès à t[n]
peut provoquer une erreur grave pendant l’exécution du programme.
C’ EST UNE DES ERREURS LES PLUS FRÉQUENTES EN C++. Soit on va
lire ou écrire dans un endroit utilisé pour une autre variable a , soit on
accède à une zone mémoire illégale et le programme peut "planter" b .
a. Dans l’exemple ci-dessus, si on remplaçait la boucle pour que i aille de 1 à 100,
x[100] irait certainement chercher y[0] à la place. De même, z[100] irait peut-être
chercher la variable i de la boucle, ce qui risquerait de faire ensuite des choses étranges,
i valant n’importe quoi !
b. Ci-dessus, z[i] avec n’importe quoi pour i irait écrire en dehors de la zone ré-
servée aux données, ce qui stopperait le programme plus ou moins délicatement !
Dans le dernier exemple, on utilise x[0] à x[99]. L’habitude est de faire une boucle
avec i<100 comme test, plutôt que i<=99, ce qui est plus lisible. Mais attention à
ne pas mettre i<=100 !
2. Ensuite :
un tableau doit avoir une taille fixe connue à la compilation. Cette taille
peut être un nombre ou une variable constante, mais pas une variable.
Même si on pense que le compilateur pourrait connaître la taille, il joue au plus

idiot et n’accepte que des constantes :
1 double x [ 1 0 ] , y [ 4 ] , z [ 5 ] ; / / OK
2 const i n t n=5;
3 i n t i [ n ] , j [ 2 ∗ n ] , k [ n + 1 ] ; / / OK
4 i n t n1 ; / / n1 n ’ a même p a s d e v a l e u r
5 i n t t 1 [ n1 ] ; / / donc ERREUR
6 i n t n2 ;
7 c i n >> n2 ; / / n2 p r e n d une v a l e u r , m a i s connue
8 / / uniquement à l ’ e x é c u t i o n
9 i n t t 2 [ n2 ] ; / / donc ERREUR
10 i n t n3 ;
11 n3 = 5 ; / / n3 p r e n d une v a l e u r , connue
12 / / à l ’ e x é c u t i o n , m a i s . . . non c o n s t a n t e
13 i n t t 3 [ n3 ] ; / / donc ERREUR ( S I ! )
56
4. Les tableaux 4.2. Initialisation
Connaissant ces deux points, on peut très facilement utiliser des tableaux. Attention
toutefois :
ne pas utiliser de tableau quand c’est inutile, notamment quand on traduit
une formule mathématique.
P100 1
Je m’explique. Si vous devez calculer s = i=1 f (i) pour f donnée , par exemple
f (i) = 3i + 4, n’allez pas écrire, comme on le voit parfois :
1 double f [ 1 0 0 ] ;
2 f o r ( i n t i = 1 ; i <=100; i ++)
3 f [ i ]=3∗ i + 4 ;
4 double s ;
5 f o r ( i n t i = 1 ; i <=100; i ++)
6 s=s+ f [ i ] ;
ni, même, ayant corrigé vos bugs :
5 double f [ 1 0 0 ] ; / / S t o c k e f ( i ) d a n s f [ i −1]
6 f o r ( i n t i = 1 ; i <=100; i ++)
7 f [ i −1]=3∗ i + 4 ; / / A t t e n t i o n aux i n d i c e s !
8 double s = 0 ; / / Ca va mieux comme c a !
9 f o r ( i n t i = 1 ; i <=100; i ++)
10 s=s+ f [ i − 1 ] ;
mais plutôt directement sans tableau :
5 double s = 0 ;
6 f o r ( i n t i = 1 ; i <=100; i ++)
7 s=s +(3∗ i + 4 ) ; / / Ou mieux : s +=3∗ i +4
ce qui épargnera, à la machine, un tableau (donc de la mémoire et des calculs), et à
vous des bugs (donc vos nerfs !). Notez qu’ici on utilise la relation de récurrence
k
X
sk = f (i) = sk−1 + f (k)
i=1
pour calculer s100 . Comme pour calculer sk on n’a besoin que de garder en mémoire
sk−1 , on peut se contenter d’une seule variable s qu’on met à jour.
4.2 Initialisation
Tout comme une variable, un tableau peut être initialisé :
int t [4]={1 ,2 ,3 ,4};
s t r i n g s [ 2 ] = { " hip " , " hop " } ;
Attention, la syntaxe utilisée pour l’initialisation ne marche pas pour une affecta-
tion 2 :
int t [ 2 ] ;
t ={1 ,2}; / / Erreur !
1. Coin des collégiens : c’est-à-dire s = f (1) + f (2) + · · · + f (100).

2. Nous verrons plus bas que l’affectation ne marche même pas entre deux tableaux ! Tout ceci s’ar-
rangera avec les objets. . .
57
4.3. Spécificités des tableaux 4. Les tableaux
4.3 Spécificités des tableaux

Les tableaux sont des variables un peu spéciales. Ils ne se comportent pas toujours
comme les autres variables 3 . . .
4.3.1 Tableaux et fonctions

Tout comme les variables, on a besoin de passer les tableaux en paramètres à des
fonctions. La syntaxe à utiliser est simple :
void a f f i c h e ( i n t s [ 4 ] ) {
f o r ( i n t i = 0 ; i < 4 ; i ++)
cout << s [ i ] << endl ;
}
...
int t [4]={1 ,2 ,3 ,4};
affiche ( t ) ;
mais il faut savoir deux choses :
— Un tableau est toujours passé par référence bien qu’on n’utilise pas le
’&’ a .
— Une fonction ne peut pas retourner un tableau b .
a. Un void f(int& t[4]) ou toute autre syntaxe est une erreur.
b. On comprendra plus tard pourquoi, par souci d’efficacité, les concepteurs du C++ ont
voulu qu’un tableau ne soit ni passé par valeur, ni retourné.
donc :
1 / / R a p p e l : c e c i ne marche p a s
2 void a f f e c t e 1 ( i n t x , i n t v a l ) {
3 x= v a l ;
4 }
5 / / R a p p e l : c ’ e s t c e c i q u i marche !
6 void a f f e c t e 2 ( i n t& x , i n t v a l ) {
7 x= v a l ;
8 }
9 / / Une f o n c t i o n q u i marche s a n s ’& ’
10 void r e m p l i t ( i n t s [ 4 ] , i n t v a l ) {
11 f o r ( i n t i = 0 ; i < 4 ; i ++)
12 s [ i ]= v a l ;
13 }
14 ...
15 i n t a =1;
3. Il est du coup de plus en plus fréquent que les programmeurs utilisent directement des variables
de type vector qui sont des objets implémentant les fonctionnalités des tableaux tout en se comportant
davantage comme des variables standard. Nous préférons ne pas parler dès maintenant des vector
car leur compréhension nécessite celle des objets et celle des "template". Nous pensons aussi que la
connaissance des tableaux, même si elle demande un petit effort, est incontournable et aide à la compré-
hension de la gestion de la mémoire.
58
4. Les tableaux 4.3. Spécificités des tableaux
16 affecte1 (a , 0 ) ; / / a ne s e r a p a s mis à 0
17 cout << a << endl ; // vérification
18 affecte2 (a , 0 ) ; / / a s e r a b i e n mis à 0
19 cout << a << endl ; // vérification
20 int t [ 4 ] ;
21 remplit ( t , 0 ) ; / / Met l e s t [ i ] à 0
22 affiche ( t ) ; / / V é r i f i e que l e s t [ i ] v a l e n t 0
et aussi :
1 / / Somme d e deux t a b l e a u x q u i ne c o m p i l e même p a s
2 / / Pour r e t o u r n e r un t a b l e a u
3 i n t somme1 ( i n t x [ 4 ] , i n t y [ 4 ] ) [ 4 ] { / / on p e u t i m a g i n e r m e t t r e l e
4 / / [ 4 ] i c i ou a i l l e u r s :
5 // rien n ’y f a i t !
6 int z [ 4 ] ;
7 f o r ( i n t i = 0 ; i < 4 ; i ++)
8 z [ i ]= x [ i ]+ y [ i ] ;
9 return z ;
10 }
11 / / En p r a t i q u e , on f e r a donc comme ç a !
12 / / Somme d e deux t a b l e a u x q u i marche
13 void somme2 ( i n t x [ 4 ] , i n t y [ 4 ] , i n t z [ 4 ] )
14 f o r ( i n t i = 0 ; i < 4 ; i ++)
15 z [ i ]= x [ i ]+ y [ i ] ; / / OK: ’ z ’ e s t p a s s é p a r r é f é r e n c e !
16 }
17
18 int a [4] ,b [ 4 ] ;
19 ... / / r e m p l i s s a g e de a e t b
20 int c [ 4 ] ;
21 c=somme1 ( a , b ) ; / / ERREUR
22 somme2 ( a , b , c ) ; / / OK
Enfin, et c’est utilisé tout le temps,
Une fonction n’est pas tenue de travailler sur une taille de tableau
unique. . . mais il est impossible de demander à un tableau sa taille !
On utilise la syntaxe int t [] dans les paramètres pour un tableau dont on ne précise
pas la taille. Comme il faut bien parcourir le tableau dans la fonction et qu’on ne peut
retrouver sa taille, on la passe en paramètre en plus du tableau :
1 / / Une f o n c t i o n q u i ne marche p a s
2 void a f f i c h e 1 ( i n t t [ ] ) {
3 f o r ( i n t i = 0 ; i <TAILLE ( t ) ; i ++) / / TAILLE ( t ) n ’ e x i s t e p a s !
4 cout << t [ i ] << endl ;
5 }
6 / / Comment on f a i t en p r a t i q u e
7 void a f f i c h e 2 ( i n t t [ ] , i n t n ) {
8 f o r ( i n t i = 0 ; i <n ; i ++)
9 cout << t [ i ] << endl ;
59
4.4. Récréations 4. Les tableaux
10 }
11 ...
12 int t1 [ 2 ] = { 1 , 2 } ;
13 int t2 [ 3 ] = { 3 , 4 , 5 } ;
14 a f f i c h e 2 ( t1 , 2 ) ; / / OK
15 a f f i c h e 2 ( t2 , 3 ) ; / / OK
4.3.2 Affectation
C’est simple :
Affecter un tableau ne marche pas ! Il faut traiter les éléments du tableau un

par un. . .
Ainsi, le programme :
int s [4]={1 ,2 ,3 ,4} , t [ 4 ] ;
t =s ; / / ERREUR d e c o m p i l a t i o n
ne marche pas et on est obligé de faire :
int s [4]={1 ,2 ,3 ,4} , t [ 4 ] ;
f o r ( i n t i = 0 ; i < 4 ; i ++)
t [ i ]= s [ i ] ; / / OK
Le problème, c’est que :
Affecter un tableau ne marche jamais mais ne génère pas toujours une er-
reur de compilation, ni même un warning. C’est le cas entre deux para-
mètres de fonction. Nous comprendrons plus tard pourquoi et l’effet exact
d’une telle affectation. . .
.
1 / / F o n c t i o n q u i ne marche p a s
2 / / Mais q u i c o m p i l e t r è s b i e n !
3 void s e t 1 ( i n t s [ 4 ] , i n t t [ 4 ] ) {
4 t =s ; / / Ne f a i t p a s c e qu ’ i l f a u t !
5 / / m a i s c o m p i l e s a n s warning !
6 }
7 / / F o n c t i o n q u i marche ( e t q u i c o m p i l e ! −)
8 void s e t 2 ( i n t s [ 4 ] , i n t t [ 4 ] ) {
9 f o r ( i n t i = 0 ; i < 4 ; i ++)
10 t [ i ]= s [ i ] ; / / OK
11 }
12 ...
13 int s [4]={1 ,2 ,3 ,4} , t [ 4 ] ;
14 s e t 1 ( s , t ) ; / / Sans e f f e t
15 s e t 2 ( s , t ) ; / / OK
60
4. Les tableaux 4.4. Récréations
F IGURE 4.1 – Des balles qui rebondissent. . . (momentanément figées ! Allez sur la page
du cours pour un programme animé !)
4.4 Récréations
4.4.1 Multi-balles
Nous pouvons maintenant reprendre le programme de la balle qui rebondit, donné
à la section 3.1.4, puis amélioré avec des fonctions et de constantes lors du TP de l’an-
nexe A.2. Grâce aux tableaux, il est facile de faire se déplacer plusieurs balles à la fois.
Nous tirons aussi la couleur et la position et la vitesse initiales des balles au hasard.
Plusieurs fonctions devraient vous être inconnues :
— L’initialisation du générateur aléatoire avec srand((unsigned int)time(0)), qui est
expliquée dans le TP 3 (annexe A.3)
— Les fonctions noRefreshBegin et noRefreshEnd qui servent à accélérer l’affichage
de toutes les balles (voir documentation de Imagine++ annexe B).
Voici le listing du programme (exemple d’affichage (malheureusement statique !) fi-
gure 4.1) :
4 # i n c l u d e <ctime >
6 // / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
7 / / C o n s t a n t e s du programme
8 c o n s t i n t width = 2 5 6 ; / / Largeur de l a f e n e t r e
9 const i n t height =256; / / Hauteur d e l a f e n e t r e
10 const i n t b a l l _ s i z e =4; / / Rayon d e l a b a l l e
11 const i n t nb_balls =30; / / Nombre d e b a l l e s
12 // / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
13 / / Generateur a l e a t o i r e
14 / / A n ’ a p p e l e r qu ’ une f o i s , a v a n t Random ( )
61
15 void InitRandom ( )
16 {
17 srand ( ( unsigned i n t ) time ( 0 ) ) ;
18 }
19 / / Entre a e t b
20 i n t Random ( i n t a , i n t b )
21 {
22 r e t u r n a +( rand ( ) % ( b−a + 1 ) ) ;
23 }
24 // / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
25 // Position et vitesse aleatoire
26 void I n i t B a l l e ( i n t &x , i n t &y , i n t &u , i n t &v , Color &c ) {
27 x=Random ( b a l l _ s i z e , width−b a l l _ s i z e ) ;
28 y=Random ( b a l l _ s i z e , height −b a l l _ s i z e ) ;
29 u=Random ( 0 , 4 ) ;
30 v=Random ( 0 , 4 ) ;
31 c=Color ( byte ( Random ( 0 , 2 5 5 ) ) ,
32 byte ( Random ( 0 , 2 5 5 ) ) ,
33 byte ( Random ( 0 , 2 5 5 ) ) ) ;
34 }
35 // / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
36 / / A f f i c h a g e d ’ une b a l l e
37 void D e s s i n e B a l l e ( i n t x , i n t y , Color c o l ) {
38 f i l l R e c t ( x−b a l l _ s i z e , y−b a l l _ s i z e , 2 ∗ b a l l _ s i z e +1 ,2∗ b a l l _ s i z e +1 , c o l ) ;
39 }
40 // / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
41 / / D e p l a c e m e n t d ’ une b a l l e
42 void BougeBalle ( i n t &x , i n t &y , i n t &u , i n t &v ) {
43 / / Rebond s u r l e s b o r d s g a u c h e e t d r o i t
44 i f ( x+u>width−b a l l _ s i z e || x+uheight −b a l l _ s i z e )
48 v=−v ;
49 / / Mise a j o u r d e l a p o s i t i o n
50 x+=u ;
51 y+=v ;
52 }
53 // / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
54 / / Fonction p r i n c i p a l e
55 i n t main ( )
56 {
57 / / Ouverture de l a f e n e t r e
58 openWindow ( width , h e i g h t ) ;
59 / / Position et v i t e s s e des b a l l e s
60 i n t xb [ n b _ b a l l s ] , yb [ n b _ b a l l s ] , ub [ n b _ b a l l s ] , vb [ n b _ b a l l s ] ;
61 Color cb [ n b _ b a l l s ] ; / / C o u l e u r s d e s b a l l e s
62 InitRandom ( ) ;
62
63 f o r ( i n t i = 0 ; i < n b _ b a l l s ; i ++) {
64 I n i t B a l l e ( xb [ i ] , yb [ i ] , ub [ i ] , vb [ i ] , cb [ i ] ) ;
65 D e s s i n e B a l l e ( xb [ i ] , yb [ i ] , cb [ i ] ) ;
66 }
67 / / Boucle p r i n c i p a l e
69 milliSleep (25);
70 noRefreshBegin ( ) ;
72 D e s s i n e B a l l e ( xb [ i ] , yb [ i ] , White ) ;
73 BougeBalle ( xb [ i ] , yb [ i ] , ub [ i ] , vb [ i ] ) ;
75 }
76 noRefreshEnd ( ) ;
77 }
79 return 0;
80 }
4.4.2 Avec des chocs !

Il n’est ensuite pas très compliqué de modifier le programme précédent pour que
les balles rebondissent entre-elles. Le listing ci-après a été construit comme suit :
1. Lorsqu’une balle se déplace, on regarde aussi si elle rencontre une autre balle. Il
faut donc que BougeBalle connaisse les positions des autres balles. On modifie
donc BougeBalle en passant les tableaux complets des positions et des vitesses,
et en précisant juste l’indice de la balle à déplacer (lignes 71 et 110). La boucle
de la ligne 78 vérifie ensuite via le test de la ligne 81 si l’une des autres balles est
heurtée par la balle courante. Auquel cas, on appelle ChocBalles qui modifie les
vitesses des deux balles. Notez les lignes 79 et 80 qui évitent de considérer le choc
d’une balle avec elle-même (nous verrons l’instruction continue une autre fois).
2. Les formules du choc de deux balles peuvent se trouver facilement dans un cours
de prépa. . . ou sur le web. La fonction ChocBalles implémente ces formules. (No-
tez l’inclusion du fichier <cmath> pour avoir accès à la racine carré sqrt () , aux
sinus et cosinus cos() et sin () , et à l’arc-cosinus acos().
3. On réalise ensuite que les variables entières qui stockent positions et vitesses font
que les erreurs d’arrondis s’accumulent et que les vitesses deviennent nulles ! On
bascule alors toutes les variables concernées en double, en pensant bien à les
reconvertir en int lors de l’affichage (ligne 37).
Le tout donne un programme bien plus animé. On ne peut évidemment constater la
différence sur une figure dans un livre. Téléchargez donc le programme sur la page du
cours !
23 / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
24 / / P o s i t i o n e t v i t e s s e a l e a t o i r e
25 void I n i t B a l l e ( double &x , double &y , double &u , double &v , Color &c ) {
26 x=Random ( b a l l _ s i z e , width−b a l l _ s i z e ) ;
63
27 y=Random ( b a l l _ s i z e , height −b a l l _ s i z e ) ;
28 u=Random ( 0 , 4 ) ;
29 v=Random ( 0 , 4 ) ;
30 c=Color ( byte ( Random ( 0 , 2 5 5 ) ) ,
31 byte ( Random ( 0 , 2 5 5 ) ) ,
32 byte ( Random ( 0 , 2 5 5 ) ) ) ;
33 }
34 // / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
35 / / A f f i c h a g e d ’ une b a l l e
36 void D e s s i n e B a l l e ( double x , double y , Color c o l ) {
37 f i l l R e c t ( i n t ( x)− b a l l _ s i z e , i n t ( y)− b a l l _ s i z e ,
38 2∗ b a l l _ s i z e +1 ,2∗ b a l l _ s i z e +1 , c o l ) ;
39 }
40 // / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
41 / / Choc e l a s t i q u e d e deux b a l l e s s p h e r i q u e s
42 / / c f l a b o . n t i c . org
43 # i n c l u d e <cmath>
44 void C h o c B a l l e s ( double&x1 , double&y1 , double&u1 , double&v1 ,
45 double&x2 , double&y2 , double&u2 , double&v2 )
46 {
47 / / Distance
48 double o2o1x=x1−x2 , o2o1y=y1−y2 ;
49 double d= s q r t ( o2o1x ∗ o2o1x+o2o1y ∗ o2o1y ) ;
50 i f ( d==0) r e t u r n ; / / Même c e n t r e ?
51 / / R e p è r e ( o2 , x , y )
52 double Vx=u1−u2 , Vy=v1−v2 ;
53 double V= s q r t ( Vx∗Vx+Vy∗Vy ) ;
54 i f (V==0) r e t u r n ; / / Même v i t e s s e
55 / / R e p è r e s u i v a n t V ( o2 , i , j )
56 double i x =Vx/V, i y =Vy/V, j x =−iy , j y = i x ;
57 / / Hauteur d ’ a t t a q u e
58 double H=o2o1x ∗ j x +o2o1y ∗ j y ;
59 / / Angle
60 double th=acos (H/d ) , c=cos ( th ) , s= s i n ( th ) ;
61 / / V i t e s s e a p r è s c h o c d a n s ( o2 , i , j )
62 double v 1 i =V∗ c ∗ c , v 1 j =V∗ c ∗ s , v 2 i =V∗ s ∗ s , v 2 j=−v 1 j ;
63 / / Dans r e p è r e d ’ o r i g i n e (O, x , y )
64 u1= v 1 i ∗ i x + v 1 j ∗ j x +u2 ;
65 v1= v 1 i ∗ i y + v 1 j ∗ j y +v2 ;
66 u2+= v 2 i ∗ i x + v 2 j ∗ j x ;
67 v2+= v 2 i ∗ i y + v 2 j ∗ j y ;
68 }
69 // / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
70 / / D e p l a c e m e n t d ’ une b a l l e
71 void BougeBalle ( double x [ ] , double y [ ] , double u [ ] , double v [ ] , i n t i )
72 { / / Rebond s u r l e s b o r d s g a u c h e e t d r o i t
73 i f ( x [ i ]+u [ i ] > width−b a l l _ s i z e || x [ i ]+u [ i ] height −b a l l _ s i z e )
77 v [ i ]=−v [ i ] ;
78 f o r ( i n t j = 0 ; j < n b _ b a l l s ; j ++) {
79 i f ( j == i )
80 continue ;
81 i f ( abs ( x [ i ]+u [ i ]−x [ j ] ) < 2 ∗ b a l l _ s i z e
82 && abs ( y [ i ]+ v [ i ]−y [ j ] ) < 2 ∗ b a l l _ s i z e ) {
83 ChocBalles ( x [ i ] , y [ i ] , u[ i ] , v [ i ] , x [ j ] , y [ j ] , u[ j ] , v [ j ] ) ;
84 }
85 }
86 / / Mise a j o u r d e l a p o s i t i o n
87 x [ i ]+=u [ i ] ;
88 y [ i ]+=v [ i ] ;
89 }
90 // / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
92 i n t main ( )
93 {
95 openWindow ( width , h e i g h t ) ;
96 / / Position et v i t e s s e des b a l l e s
97 double xb [ n b _ b a l l s ] , yb [ n b _ b a l l s ] , ub [ n b _ b a l l s ] , vb [ n b _ b a l l s ] ;
98 Color cb [ n b _ b a l l s ] ; / / C o u l e u r s d e s b a l l e s
99 InitRandom ( ) ;
101 I n i t B a l l e ( xb [ i ] , yb [ i ] , ub [ i ] , vb [ i ] , cb [ i ] ) ;
103 }
105 while ( t r u e ) {
106 milliSleep (25);
107 noRefreshBegin ( ) ;
109 D e s s i n e B a l l e ( xb [ i ] , yb [ i ] , White ) ;
110 BougeBalle ( xb , yb , ub , vb , i ) ;
112 }
113 noRefreshEnd ( ) ;
114 }
116 return 0;
117 }
65
4.4.3 Mélanger les lettres

Le programme suivant considère une phrase et permute aléatoirement les lettres
intérieures de chaque mot (c’est-à-dire sans toucher aux extrémités des mots). Il utilise
pour cela le type string, chaîne de caractère, pour lequel s[ i ] renvoie le i-ème caractère
de la chaîne s, et s . size () le nombre de caractères de s (nous expliquerons plus tard la
notation "objet" de cette fonction). La phrase considérée ici devient par exemple :
Ctete pteite psahre dreviat erte ecorne libslie puor vorte parvue ceeravu
L’avez-vous comprise ? Peu importe ! C’est le listing que vous devez comprendre :
2 # include <string >
4 # i n c l u d e <ctime >
6
7 // / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
8 / / Generateur a l e a t o i r e
9 / / A n ’ a p p e l e r qu ’ une f o i s , a v a n t Random ( )
10 void InitRandom ( )
11 {
12 srand ( ( unsigned i n t ) time ( 0 ) ) ;
13 }
14 / / Entre a e t b
15 i n t Random ( i n t a , i n t b )
16 {
17 r e t u r n a +( rand ( ) % ( b−a + 1 ) ) ;
18 }
19
20 // / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
21 / / Permuter l e s l e t t r e s i n t e r i e u r e s de s n f o i s
22 s t r i n g Melanger ( s t r i n g s , i n t n )
23 {
24 int l=int ( s . size ( ) ) ;
25 i f ( l <=3)
26 return s ;
27 s t r i n g t =s ;
28 f o r ( i n t i = 0 ; i <n ; i ++) {
29 i n t a=Random ( 1 , l − 2 ) ;
30 int b ;
31 do
32 b=Random ( 1 , l − 2 ) ;
33 while ( a==b ) ;
34 char c= t [ a ] ;
35 t [ a ]= t [ b ] ; t [ b ]= c ;
36 }
37 return t ;
38 }
66
4. Les tableaux 4.5. TP
F IGURE 4.2 – Master mind. . .
39
40 i n t main ( )
41 {
42 const i n t n=11;
43 s t r i n g phrase [ n ] = { " C e t t e " , " p e t i t e " , " phrase " , " d e v r a i t " , " e t r e " ,
44 " encore " , " l i s i b l e " , " pour " , " v o t r e " , " pauvre " ,
45 " cerveau " } ;
46
47 InitRandom ( ) ;
48 f o r ( i n t i = 0 ; i <n ; i ++)
49 cout << Melanger ( phrase [ i ] , 3 ) << " " ;
50 cout << endl ;
51
52 return 0;
53 }
4.5 TP
Nous pouvons maintenant aller faire le troisième TP donné en annexe A.3 afin de
mieux comprendre les tableaux et aussi pour obtenir un master mind (voir figure 4.2
le résultat d’une partie intéressante !).
67
4.6. Fiche de référence 4. Les tableaux
Comme promis, nous complétons, en rouge, la "fiche de référence" avec ce qui a été
vu pendant ce chapitre et son TP.

Variables n=10; // OK — double x[5],y[5];
— Définition : int i=m; // OK for(int i=0;i<5;i++)
int i; ... y[i]=2*x[i];
int k,l,m; — Conversion : — const int n=5;
— Affectation : int i=int(x),j; int i[n],j[2*n];
i=2; float x=float(i)/j;
— Initialisation :
j=i; int t[4]={1,2,3,4};
Tests
k=l=3; string s[2]={"ab","c"};
— Initialisation : — Comparaison :
== != < > <= >= — Affectation :
int n=5,o=n; int s[3]={1,2,3},t[3];
— Constantes : — Négation : !
for (int i=0;i<3;i++)
const int s=12; — Combinaisons : && || t[i]=s[i];
— Portée : — if (i==0) j=1; — En paramètre :
int i;
— if (i==0) j=1; — void init(int t[4]) {
// i=j; interdit!
else j=2; for(int i=0;i<4;i++)
int j=2;
i=j; // OK! t[i]=0;
if (j>1) { — if (i==0) { }
int k=3; j=1; — void init(int t[],
j=k; // OK! k=2; int n) {
} } for(int i=0;i<n;i++)
//i=k; interdit! — bool t=(i==0); t[i]=0;
— Types : if (t) }
int i=3; j=1;
double x=12.3; Boucles
— switch (i) {
char c=’A’; case 1: — do {
string s="hop"; ...; ...
bool t=true; ...; } while(!ok);
float y=1.2f; break; — int i=1;
unsigned int j=4; case 2: while(i<=100) {
signed char d=-128; case 3: ...
unsigned char d=25; ...; i=i+1;
complex<double> break; }
z(2,3); default:
...; — for(int i=1;i<=10;i++)
— Variables globales : } ...
int n; — for(int i=1,j=10;j>i;
const int m=12; Tableaux i=i+2,j=j-3)
void f() { — Définition : ...
68
4. Les tableaux 4.6. Fiche de référence

Fonctions int b); — int f() {...}
— Définition : double hasard(); int i=f; // NON!
int plus(int a,int b){ Divers — double x=1/3; // NON!
int c=a+b; int i,j;
— i++;
return c; x=i/j; // NON!
i--;
} x=double(i/j); //NON!
i-=2;
void affiche(int a) { — double x[10],y[10];
j+=3;
cout << a << endl; for(int i=1;i<=10;i++)
} — j=i%n; // Modulo
y[i]=2*x[i];//NON
— #include <cstdlib>
— Déclaration : — int n=5;
...
int plus(int a,int b); int t[n]; // NON
i=rand()%n;
— Retour : x=rand()/ — int f()[4] { // NON!
int signe(double x) { double(RAND_MAX); int t[4];
if (x<0) — #include <ctime> ...
return -1; // Un seul appel return t; // NON!
if (x>0) srand((unsigned int) }
return 1; time(0)); int t[4]; t=f();
return 0;
— #include <cmath> — int s[3]={1,2,3},t[3];
}
double sqrt(double x); t=s; // NON!
void afficher(int x,
double cos(double x);
int y) { — int t[2];
double sin(double x);
if (x<0 || y<0) t={1,2}; // NON!
double acos(double x);
return;
if (x>=w || y>=h) — #include <string> Imagine++
return; using namespace std;
— Voir documentation. . .
DrawPoint(x,y,RED); string s="hop";
} char c=s[0]; Clavier
int l=s.size();
— Appel : — Debug : F5
int f(int a) { ... } Entrées/Sorties
— Step over : F10
int g() { ... } — #include <iostream>
... using namespace std; — Step inside : F11
int i=f(2),j=g(); ... — Indent : Ctrl+A,Ctrl+I
— Références : cout <<"I="<<i<<endl;
void swap(int& a, cin >> i >> j; Conseils
int& b){ — Nettoyer en quittant.
Erreurs fréquentes
int tmp=a;
— Pas de définition de fonction — Erreurs et warnings : cliquer.
a=b;b=tmp;
} dans une fonction ! — Indenter.
... — int q=r=4; // NON! — Ne pas laisser de warning.
int x=3,y=2; — if (i=2) // NON!
swap(x,y); — Utiliser le debuggeur.
if i==2 // NON!
— Surcharge : if (i==2) then // NON! — Faire des fonctions.
int hasard(int n); — for(int i=0,i<100,i++) — Tableaux : pas pour transcrire
int hasard(int a, // NON! une formule mathématique !
69
5. Les structures
Chapitre 5
Les structures
Les fonctions et les boucles nous ont permis de regrouper des instructions identiques. Les
tableaux permettent de grouper des variables de même type, mais pour manipuler plusieurs va-
riables simultanément, il est tout aussi indispensable des fabriquer des structures de données. . .
5.1 Révisions
Avant cela, il est utile de nous livrer à une petite révision, qui prendra la forme d’un
inventaire des erreurs classiques commises par de nombreux débutants. . . et même de
celles, plus rares mais plus originales, constatées chez certains ! Enfin, nous répéterons,
encore et toujours, les mêmes conseils.
5.1.1 Erreurs classiques

En vrac :
— Mettre un seul = dans les tests : if ( i=2)
— Oublier les parenthèses : if i==2
— Utiliser then : if ( i==2) then
— Mettre des virgules dans un for : for ( int i=0,i<100,i++)
— Oublier les parenthèses quand on appelle une fonction sans paramètre :
int f () { . . . }
...
int i=f ;
— Vouloir affecter un tableau à un autre :

int s [4]={1 ,2 ,3 ,4} , t [ 4 ] ;
t =s ;
5.1. Révisions 5. Les structures
5.1.2 Erreurs originales

Là, le débutant ne se trompe plus : il invente carrément avec sans doute le fol espoir
que ça existe peut-être. Souvent, non seulement ça n’existe pas, mais en plus ça ne colle
ni aux grands principes de la syntaxe du C++, ni même à ce qu’un compilateur peut
comprendre ! Deux exemples :
— Mélanger la syntaxe (si peu !) :
void s e t ( i n t t [ 5 ] ) {
...
}
...
int s [ 5 ] ; / / J u s q u e l à , t o u t va b i e n !
s e t ( i n t s [ 5 ] ) ; / / Là , c ’ e s t quand même n ’ i m p o r t e q u o i !
alors qu’il suffit d’un :
set ( s ) ;
— Vouloir faire plusieurs choses à la fois, ou ne pas comprendre qu’un programme

est une suite d’instructions à exécuter l’une après l’autre et non pas une for-
Pn
1
Sn . Par exemple, croire que le for est un symbole mathématique comme 1
mule
ou 1 . Ainsi, pour exécuter une instruction quand tous les ok(i) sont vrais, on a
déjà vu tenter un :
i f ( f o r ( i n t i = 0 ; i <n ; i ++) ok ( i ) ) / / Du g r a n d a r t . . .
...
alors qu’il faut faire :
bool a l l o k = t r u e ;
f o r ( i n t i = 0 ; i <n ; i ++)
a l l o k =( a l l o k && ok ( i ) ) ;
i f ( allok )
...
ou même mieux (voyez-vous la différence ?) :
f o r ( i n t i = 0 ; i <n && a l l o k ; i ++)
a l l o k =( a l l o k && ok ( i ) ) ;
i f ( allok )
...
qu’on peut finalement simplifier en :
f o r ( i n t i = 0 ; i <n && a l l o k ; i ++)
a l l o k =ok ( i ) ;
i f ( allok )
...
1. Ne me faites pas dire ce que je n’ai pas dit ! Les informaticiens théoriques considèrent parfois les
programmes comme des formules, mais ça n’a rien à voir !
72
5. Les structures 5.2. Les structures
Il est compréhensible que le débutant puisse être victime de son manque de savoir,
d’une mauvaise assimilation des leçons précédentes, de la confusion avec un autre
langage, ou de son imagination débordante ! Toutefois, il faut bien comprendre qu’un
langage est finalement lui aussi un programme, limité et conçu pour faire des choses
bien précises. En conséquence, il est plus raisonnable d’adopter la conduite suivante :
Tout ce qui n’a pas été annoncé comme possible est impossible !
5.1.3 Conseils
— Indenter. Indenter. Indenter !
— Cliquer sur les messages d’erreurs et de warnings pour aller directement à la
bonne ligne !
— Ne pas laisser de warning.
— Utiliser le debuggeur.
5.2 Les structures

5.2.1 Définition
Si les tableaux permettent de manipuler plusieurs variables d’un même type, les
structures sont utilisées pour regrouper plusieurs variables afin de les manipuler comme
une seule. On crée un nouveau type, dont les variables en question deviennent des
"sous-variables" appelées champs de la structure. Voici par exemple un type Point pos-
sédant deux champs de type double nommés x et y :
s t r u c t Point {
double x , y ;
};
Les champs se définissent avec la syntaxe des variables locales d’une fonction. Atten-
tion par contre à
Ne pas oublier le point virgule après l’accolade qui ferme la définition de la

structure !
L’utilisation est alors simple. La structure est un nouveau type qui se manipule exacte-
ment comme les autres, avec la particularité supplémentaire qu’on accède aux champs
avec un point :
Point a ;
a . x=2.3;
a . y=3.4;
On peut évidemment définir des champs de différents types, et même des structures
dans des structures :
s t r u c t Cercle {
Point centre ;
double rayon ;
73
5.2. Les structures 5. Les structures
Color c o u l e u r ;
};
Cercle C;
C. centre . x =12.;
C. centre . y =13.;
C . rayon = 1 0 . 4 ;
C . c o u l e u r =Red ;
L’intérêt des structures est évident et il faut
Regrouper dans des structures des variables dès qu’on repère qu’elles sont
logiquement liées. Si un programme devient pénible parce qu’on passe
systématiquement plusieurs paramètres identiques à de nombreuses fonc-
tions, alors il est vraisemblable que les paramètres en question puissent
être avantageusement regroupés en une structure. Ce sera plus simple et
plus clair.
5.2.2 Utilisation
Les structures se manipulent comme les autres types 2 . La définition, l’affectation,
l’initialisation, le passage en paramètre, le retour d’une fonction : tout est semblable
au comportement des types de base. Seule nouveauté : on utilise des accolades pour
préciser les valeurs des champs en cas d’initialisation 3 . On peut évidemment faire
des tableaux de structures. . . et même définir un champ de type tableau ! Ainsi, les
lignes suivantes se comprennent facilement :
P o i n t a = { 2 . 3 , 3 . 4 } , b=a , c ; // Initialisations
c=a ; // Affectations
C e r c l e C= { { 1 2 , 1 3 } , 1 0 . 4 , Red } ; / / I n i t i a l i s a t i o n
...
double d i s t a n c e ( P o i n t a , P o i n t b ) { / / Passage par valeur
r e t u r n s q r t ( ( a . x−b . x ) ∗ ( a . x−b . x ) + ( a . y−b . y ) ∗ ( a . y−b . y ) ) ;
}
void a g r a n d i r ( C e r c l e& C , double e c h e l l e ) { / / Par r é f é r e n c e
C . rayon=C . rayon ∗ e c h e l l e ; / / M o d i f i e l e r a y o n
}
Point milieu ( Point a , Point b ) { // retour
P o i n t M;
M. x =( a . x+b . x ) / 2 ;
M. y =( a . y+b . y ) / 2 ;
r e t u r n M;
}
...
Point P [ 1 0 ] ; / / Tableau de s t r u c t u r e s
f o r ( i n t i = 0 ; i < 1 0 ; i ++) {
P [ i ] . x= i ;
2. D’ailleurs, nous avions bien promis que seuls les tableaux avaient des particularités (passage par
référence, pas de retour possible et pas d’affectation.
3. Comme pour un tableau !
74
5. Les structures 5.2. Les structures
F IGURE 5.1 – Corps célestes et duel. . .
P [ i ] . y= f ( i ) ;
}
...
/ / Un d é b u t d e j e u d e Yam ’ s
s t r u c t Tirage { / /
i n t de [ 5 ] ; / / champ d e t y p e t a b l e a u
};
Tirage lancer ( ) {
Tirage t ;
f o r ( i n t i = 0 ; i < 5 ; i ++)
t . de [ i ]=1+ rand ( ) % 6 ; / / Un d é d e 1 à 6
return t ;
}
...
Tirage t ;
t=lancer ( ) ;
Attention, tout comme pour les tableaux, la syntaxe utilisée pour l’initialisation ne
marche pas pour une affectation 4 :
Point P ;
P={1 ,2}; / / Erreur !
D’ailleurs, répétons-le :
Tout ce qui n’a pas été annoncé comme possible est impossible !
4. La situation s’améliorera avec les objets.
75
5.3. Récréation : TP 5. Les structures
5.3 Récréation : TP
Nous pouvons maintenant aller faire le TP de l’annexe A.4 afin de mieux com-
prendre les structures. Nous ferons même des tableaux de structures 5 ! Nous obtien-
drons un projectile naviguant au milieu des étoiles puis un duel dans l’espace (fi-
gure 5.1) !

Encore une fois, nous complétons, en rouge, la "fiche de référence" avec ce qui a été
vu pendant ce chapitre et son TP.

Variables unsigned int j=4; — bool t=(i==0);
— Définition : signed char d=-128; if (t)
int i; unsigned char d=25; j=1;
int k,l,m; complex<double> — switch (i) {
z(2,3); case 1:
— Affectation :
...;
i=2;
— Variables globales : ...;
j=i;
int n; break;
k=l=3;
const int m=12; case 2:
— Initialisation : void f() { case 3:
int n=5,o=n; n=10; // OK ...;
— Constantes : int i=m; // OK break;
const int s=12; ... default:
— Conversion : ...;
— Portée : }
int i=int(x),j;
int i;
float x=float(i)/j;
// i=j; interdit! Boucles
int j=2; Tests — do {
i=j; // OK! — Comparaison : ...
if (j>1) { == != < > <= >= } while(!ok);
int k=3;
— Négation : ! — int i=1;
j=k; // OK!
} — Combinaisons : && || while(i<=100) {
//i=k; interdit! — if (i==0) j=1; ...
i=i+1;
— Types : — if (i==0) j=1;
}
int i=3; else j=2;
double x=12.3; — for(int i=1;i<=10;i++)
char c=’A’; — if (i==0) { ...
string s="hop"; j=1; — for(int i=1,j=10;j>i;
bool t=true; k=2; i=i+2,j=j-3)
float y=1.2f; } ...
5. Coin des collégiens : il y a dans ce TP des mathématiques et de la physique pour étudiant de

l’enseignement supérieur. . . mais on peut très bien faire les programmes en ignorant tout ça !
76
5. Les structures 5.4. Fiche de référence

Fonctions — const int n=5; — #include <string>
— Définition : int i[n],j[2*n]; using namespace std;
int plus(int a,int b){ — Initialisation : string s="hop";
int c=a+b; int t[4]={1,2,3,4}; char c=s[0];
return c; string s[2]={"ab","c"}; int l=s.size();
} — Affectation :
void affiche(int a) { Entrées/Sorties
int s[3]={1,2,3},t[3];
cout << a << endl; for (int i=0;i<3;i++) — #include <iostream>
} t[i]=s[i]; using namespace std;
— Déclaration : ...
— En paramètre :
int plus(int a,int b); cout <<"I="<<i<<endl;
— void init(int t[4]) { cin >> i >> j;
— Retour : for(int i=0;i<4;i++)
int signe(double x) { t[i]=0; Erreurs fréquentes
if (x<0) }
return -1; — Pas de définition de fonction
if (x>0) — void init(int t[], dans une fonction !
return 1; int n) {
return 0; for(int i=0;i<n;i++)
} t[i]=0; — if (i=2) // NON!
void afficher(int x, } if i==2 // NON!
int y) { if (i==2) then // NON!
Structures
if (x<0 || y<0) — for(int i=0,i<100,i++)
— struct Point {
return; // NON!
double x,y;
if (x>=w || y>=h) — int f() {...}
Color c;
return; int i=f; // NON!
};
DrawPoint(x,y,RED);
... — double x=1/3; // NON!
}
Point a; int i,j;
— Appel : a.x=2.3; a.y=3.4; x=i/j; // NON!
int f(int a) { ... } a.c=Red; x=double(i/j); //NON!
int g() { ... } Point b={1,2.5,Blue};
... — double x[10],y[10];
int i=f(2),j=g(); Divers for(int i=1;i<=10;i++)
— Références : — i++; y[i]=2*x[i];//NON
void swap(int& a, i--; — int n=5;
int& b){ i-=2; int t[n]; // NON
int tmp=a; j+=3;
— int f()[4] { // NON!
a=b;b=tmp; — j=i%n; // Modulo int t[4];
}
— #include <cstdlib> ...
...
... return t; // NON!
int x=3,y=2;
i=rand()%n; }
swap(x,y);
x=rand()/ int t[4]; t=f();
— Surcharge : double(RAND_MAX);
int hasard(int n); — int s[3]={1,2,3},t[3];
int hasard(int a, — #include <ctime> t=s; // NON!
int b); // Un seul appel
— int t[2];
double hasard(); srand((unsigned int)
t={1,2}; // NON!
time(0));
Tableaux — #include <cmath> — struct Point {
— Définition : double sqrt(double x); double x,y;
— double x[5],y[5]; double cos(double x); } // NON!
for(int i=0;i<5;i++) double sin(double x); — Point a;
y[i]=2*x[i]; double acos(double x); a={1,2}; // NON!
77
5.4. Fiche de référence 5. Les structures

Imagine++ — Step inside : F11 — Ne pas laisser de warning.
— Voir documentation. . . — Indent : Ctrl+A,Ctrl+I — Utiliser le debuggeur.
Conseils — Faire des fonctions.
Clavier
— Nettoyer en quittant. — Tableaux : pas pour transcrire
— Debug : F5 une formule mathématique !
— Erreurs et warnings : cliquer.
— Step over : F10 — Indenter. — Faire des structures.
78
6. Plusieurs fichiers !
Chapitre 6
Plusieurs fichiers !
Lors du dernier TP, nous avons réalisé deux projets quasiment similaires dont seuls les
main() étaient différents. Modifier après coup une des fonctions de la partie commune aux
deux projets nécessiterait d’aller la modifier dans les deux projets. Nous allons voir maintenant
comment factoriser cette partie commune dans un seul fichier, de façon à en simplifier les éven-
tuelles futures modifications. Au passage 1 nous verrons comment définir un opérateur sur de
nouveaux types.
Résumons notre progression dans le savoir-faire du programmeur :

1. Tout programmer dans le main() : c’est un début et c’est déjà bien !
2. Faire des fonctions : pour être plus lisible et ne pas se répéter ! (Axe des instruc-
tions)
3. Faire des tableaux et des structures : pour manipuler plusieurs variables à la fois.
(Axe des données)
Nous rajoutons maintenant :
4. Faire plusieurs fichiers : pour utiliser des parties communes dans différents pro-
jets ou solutions. (A nouveau, axe des instructions)
F IGURE 6.1 – Plusieurs fichiers sources (dans QtCreator).
1. Toujours cette idée que nous explorons les différentes composantes du langages quand le besoin
s’en fait sentir.
6.1. Fichiers séparés 6. Plusieurs fichiers !
6.1 Fichiers séparés

Nous allons répartir notre code source dans plusieurs fichiers. Mais avant toute
chose :
Pour un maximum de portabilité du code, choisir des noms de fichiers avec
seulement des caractères standard (pas de lettres accentuées ni d’espace)
D’ailleurs il est aussi préférable d’éviter les accents pour les noms de variables et de
fonctions, tant pis pour la correction du français. . .
6.1.1 Principe
Jusqu’à présent un seul fichier source contenait notre programme C++. Ce fichier
source était transformé en fichier objet par le compilateur puis le linker complétait le
fichier objet avec les bibliothèques du C++ pour en faire un fichier exécutable. En fait,
un projet peut contenir plusieurs fichiers sources. Il suffit pour cela de rajouter un
fichier .cpp à la liste des sources du projet :
— Dans QtCreator, ouvrir le menu File/New File or Project ou faire Ctrl+N,
choisir comme modèle C++ Source File, lui donner un nom et bien s’assurer
qu’on le met dans le dossier des sources (et non dans le dossier de build).
— Rajouter ce fichier dans le CMakeLists.txt :
a d d _e xe cu ta bl e (Hop main . cpp hop . cpp )
Ainsi, en rajoutant un fichier C++ hop à un projet contenant déjà main.cpp, on se

retrouve avec une structure de projet identique à celle de la figure 6.1.
Après cela, chaque génération du projet consistera en :
1. Compilation : chaque fichier source est transformé en un fichier objet (de même
nom mais de suffixe .obj). Les fichiers sources sont donc compilés indépendam-
ment les uns des autres.
2. Link : les différents fichiers objets sont réunis (et complétés avec les bibliothèques
du C++) en un seul fichier exécutable (de même nom que le projet).
Une partie des instructions du fichier principal (celui qui contient main()) peut donc
être déportée dans un autre fichier. Cette partie sera compilée séparément et réintégrée
pendant l’édition des liens. Se pose alors le problème suivant : comment utiliser dans
le fichier principal ce qui se trouve dans les autres fichiers ? En effet, nous savions
(cf section 3.2.4) qu’une fonction n’était "connue" que dans les lignes qui suivaient
sa définition ou son éventuelle déclaration. Par "connue", il faut comprendre que le
compilateur sait qu’il existe ailleurs une fonction de tel nom avec tel type de retour et
tels paramètres. Malheureusement 2 :
une fonction n’est pas "connue" en dehors de son fichier. Pour l’utiliser dans
un autre fichier, il faut donc l’y déclarer !
En clair, nous allons devoir procéder ainsi :

2. Heureusement, en fait, car lorsque l’on réunit des fichiers de provenances multiples, il est préfé-
rable que ce qui se trouve dans les différents fichiers ne se mélange pas de façon anarchique. . .
80
6. Plusieurs fichiers ! 6.1. Fichiers séparés
— Fichier hop.cpp :
// Définitions
void f ( i n t x ) {
...
}
int g () {
...
}
/ / Autres f o n c t i o n s
...
— Fichier main.cpp :
// Déclarations
void f ( i n t x ) ;
int g ( ) ;
...
i n t main ( ) {
...
// Utilisation
i n t a=g ( ) ;
f (a );
...
Nous pourrions aussi évidemment déclarer dans hop.cpp certaines fonctions de main.cpp
pour pouvoir les utiliser. Attention toutefois : si des fichiers s’utilisent de façon croisée,
c’est peut-être que nous sommes en train de ne pas découper les sources convenable-
ment.
6.1.2 Avantages
Notre motivation initiale était de mettre une partie du code dans un fichier séparé
pour l’utiliser dans un autre projet. En fait, découper son code en plusieurs fichiers a
d’autres intérêts :
— Rendre le code plus lisible et évitant les fichiers trop longs et en regroupant les
fonctions de façon structurée.
— Accélérer la compilation. Lorsqu’un programme devient long et complexe, le
temps de compilation n’est plus négligeable. Or, lorsque l’on régénère un projet,
l’environnement de programmation ne recompile que les fichiers sources qui ont
été modifiés depuis la génération précédente. Il serait en effet inutile de recompi-
ler un fichier source non modifié pour ainsi obtenir le même fichier objet 3 ! Donc
changer quelques lignes dans un fichier n’entraînera pas la compilation de tout
le programme mais seulement du fichier concerné.
Attention toutefois à ne pas séparer en de trop nombreux fichiers ! Il devient alors plus
compliqué de s’y retrouver et de naviguer parmi ces fichiers.
3. C’est en réalité un peu plus compliqué : un source peu dépendre, via des inclusions (cf sec-
tion 6.1.4), d’autres fichiers, qui, eux, peuvent avoir été modifiés ! Il faut alors recompiler un fichier
dont une dépendance a été modifiée. Ces dépendances sont gérées automatiquement par Cmake.
81
F IGURE 6.2 – Même source dans deux projets : hop.cpp et hop.h sont partagés par
les deux projets, même s’ils se trouvent dans le dossier Projet
6.1.3 Utilisation dans un autre projet

6.1.4 Fichiers d’en-têtes
Le fichier séparé nous permet de factoriser une partie du source. Toutefois, il faut
taper les déclarations de toutes les fonctions utilisées dans chaque fichier les utilisant.
Nous pouvons mieux faire 4 . Pour cela, il est temps d’expliquer ce que fait l’instruction
#include que nous rencontrons depuis nos débuts :
La ligne #include "nom" est automatiquement remplacée par le contenu

du fichier nom avant de procéder à la compilation.
Il s’agit bien de remplacer par le texte complet du fichier nom comme avec un simple
copier/coller. Cette opération est faite avant la compilation par un programme dont
nous n’avions pas parlé : le pré-processeur. Les lignes commençant par un # lui seront
destinées. Nous en verrons d’autres. Attention : jusqu’ici nous utilisions une forme
légèrement différente : #include <nom>, qui va chercher le fichier nom dans les dossiers
des bibliothèques C++ 5 .
Grâce à cette possibilité du pré-processeur, il nous suffit de mettre les déclarations
se rapportant au fichier séparé dans un troisième fichier et de l’inclure dans les fichiers
principaux. Il est d’usage de prendre pour ce fichier supplémentaire le même nom que
le fichier séparé, mais avec l’extension .h : on appelle ce fichier un fichier d’en-tête 6 .
Pour créer ce fichier, faire comme pour le source, mais en choisissant "C++ Header File"
au lieu de "C++ Source File". Voila ce que cela donne :
// Définitions
4. Toujours le moindre effort. . .
5. Les fichiers d’en-tête iostream, etc. sont parfois appelés en-têtes système. Leur nom ne se termine
pas toujours par .h (voir après), mais rien ne les distingue fondamentalement d’un fichier d’en-tête
habituel. Certains noms de headers système commencent par la lettre c, comme cmath, ce sont ceux
hérités du C.
6. .h comme header, on voit aussi parfois .hpp pour les distinguer des headers du C.
82
...
}
int g () {
...
}
...
— Fichier hop.h :
// Déclarations
void f ( i n t x ) ;
int g ( ) ;
— Fichier main.cpp du premier projet :

# i n c l u d e " hop . h "
...
i n t main ( ) {
...
// Utilisation
i n t a=g ( ) ;
f (a );
...
— Fichier main2.cpp du deuxième projet (il faut préciser l’emplacement complet

de l’en-tête, qui se trouve dans le dossier du premier projet 7 ) :
# i n c l u d e " . . / P r o j e c t 1 /hop . h "
...
i n t main ( ) {
...
// Utilisation
f (12);
i n t b=g ( ) ;
...
En fait, pour être sûr que les fonctions définies dans hop.cpp sont cohérentes avec leur
déclaration dans hop.h, et bien que ça ne soit pas obligatoire, on inclut aussi l’en-tête
dans le source, ce qui donne :
# i n c l u d e " hop . h "
...
// Définitions
...
}
int g () {
7. On peut aussi préciser au compilateur une liste de dossiers où il peut aller chercher les fichiers
d’en-tête, voir la section 6.1.8.
83
...
}
...
En pratique, le fichier d’en-tête ne contient pas seulement les déclarations des fonc-
tions mais aussi les définitions des nouveaux types (comme les structures) utilisés par
le fichier séparé. En effet, ces nouveaux types doivent être connus du fichier séparé,
mais aussi du fichier principal. Il faut donc vraiment :
1. Mettre dans l’en-tête les déclarations des fonctions et les définitions

des nouveaux types.
2. Inclure l’en-tête dans le fichier principal mais aussi dans le fichier sé-
paré.
Cela donne par exemple :

— Fichier vect.h :
/ / Types
s t r u c t Vecteur {
double x , y ;
};
// Déclarations
double norme ( Vecteur V ) ;
Vecteur plus ( Vecteur A, Vecteur B ) ;
— Fichier vect.cpp :
# include " vect . h" / / Fonctions e t t y p e s
// Définitions
double norme ( Vecteur V) {
...
}
Vecteur plus ( Vecteur A, Vecteur B ) {
...
}
...
— Fichier main.cpp du premier :

# include " vect . h"
...
i n t main ( ) {
...
// Utilisation
Vecteur C=plus (A, B ) ;
double n=norme (C ) ;
...
84
Votre environnement de développement vous permet de naviguer facilement entre

les différents fichiers de votre projet. Par exemple, avec QtCreator, vous pouvez passer
du header au source ou vice-versa par l’option "Switch Header/Source" (F4) du menu
contextuel obtenu par un clic droit dans l’éditeur. Pour suivre un include, vous pou-
vez aussi vous mettre sur le nom du fichier et choisir l’option "Follow Symbol Under
Cursor" (F2) du même menu.
6.1.5 À ne pas faire. . .

Il est "fortement" conseillé de :
1. ne pas déclarer dans l’en-tête toutes les fonctions du fichier séparé mais seule-
ment celles qui seront utilisées par le fichier principal. Les fonctions secondaires
n’ont pas à apparaître 8 .
2. ne jamais inclure un fichier séparé lui-même ! C’est généralement une "grosse
bêtise" 9 . Donc
pas de #include "vect.cpp" !
6.1.6 Implémentation
Finalement, la philosophie de ce système est que
— Le fichier séparé et son en-tête forment un tout cohérent, implémentant

un certain nombre de fonctionnalités.
— Celui qui les utilise, qui n’est pas nécessairement celui qui les a pro-
grammés, se contente de rajouter ces fichiers à son projet, d’inclure
l’en-tête dans ses sources et de profiter de ce que l’en-tête déclare.
— Le fichier d’en-tête doit être suffisamment clair et informatif pour que
l’utilisateur n’ait pas à regarder le fichier séparé lui-même a .
a. D’ailleurs, si l’utilisateur le regarde, il peut être tenté de tirer profit de ce qui s’y trouve et
d’utiliser plus que ce que l’en-tête déclare. Or, le créateur du fichier séparé et de l’en-tête peut
par la suite être amené à changer dans son source la façon dont il a programmé les fonctions
sans pour autant changer leurs fonctionnalités. L’utilisateur qui a "triché" en allant regarder
dans le fichier séparé peut alors voir ses programmes ne plus marcher. Il n’a pas respecté la
règle du jeu qui était de n’utiliser que les fonctions de l’en-tête sans savoir comment elles sont
implémentées. Nous reparlerons de tout ça avec les objets. Nous pourrons alors faire en sorte
que l’utilisateur ne triche pas. . . De toute façon, à notre niveau actuel, le créateur et l’utilisateur
sont une seule et même personne. À elle de ne pas tricher !
8. On devrait même tout faire pour bien les cacher et pour interdire au fichier principal de les utiliser.
Il serait possible de le faire dès maintenant, mais nous en reparlerons plutôt quand nous aborderons les
objets. . .
9. Une même fonction peut alors se retrouver définie plusieurs fois : dans le fichier séparé et dans le
fichier principal qui l’inclut. Or, s’il est possible de déclarer autant de fois que nécessaire une fonction, il
est interdit de la définir plusieurs fois (ne pas confondre avec la surcharge qui rend possible l’existence
de fonctions différentes sous le même nom—cf. section 3.2.6)
85
6.1. Fichiers séparés 6. Plusieurs fichiers!
6.1.7 Inclusions mutuelles

En passant à l’action, le débutant découvre souvent des problèmes non prévus lors
du cours. Il est même en général imbattable pour cela ! Le problème le plus fréquent
qui survient avec les fichiers d’en-tête est celui de l’inclusion mutuelle. Il arrive que les
fichiers d’en-tête aient besoin d’en inclure d’autres eux-mêmes. Or, si le fichier A.h
inclut B.h et si B.h inclut A.h alors toute inclusion de A.h ou de B.h se solde par une
phénomène d’inclusions sans fin qui provoque une erreur 10 . Pour éviter cela, on utilise
une instruction du pré-processeur signalant qu’un fichier déjà inclus ne doit plus l’être
à nouveau : on ajoute
#pragma once au début de chaque fichier d’en-tête.
Certains compilateurs peuvent ne pas connaître #pragma once. On utilise alors une
astuce que nous donnons sans explication :
— Choisir un nom unique propre au fichier d’en-tête. Par exemple VECT_H pour le
fichier vect.h.
— Placer #ifndef VECT_H et #define VECT_H au début du fichier vect.h et #endif
à la fin.
Cela utilise la commande if du préprocesseur. Notons un autre usage parfois utile en
cours de développement pour que le compilateur ne regarde pas tout un bloc de code :
#if 0
N’ importe quoi i c i , ce s e r a i g n o r é par l e c o m p i l a t e u r .
# endif
6.1.8 Chemin d’inclusion

Puisque le #include prend un fichier, la question se pose de savoir où le préproces-
seur doit chercher. Pour les fichiers du système, par exemple #include <iostream>, leur
chemin est connu du compilateur et on n’a pas à s’en occuper. Pour les autres, il y a
deux règles de recherche :
— dans le dossier courant, celui qui contient le cpp ;
— dans une liste de dossiers indiqués par l’utilisateur.
Pour le deuxième cas, on dispose de l’instruction include_directories de Cmake,
à utiliser dans le CMakeLists.txt. Par exemple, quand on fait 11
# i n c l u d e " Imagine/Graphics . h "
il va chercher un dossier Imagine contenant un fichier Graphics.h. (Toujours utili-
ser le slash direct /, qui fonctionne sur toutes les plates-formes, et non le backslash \
qui ne fonctionne que sous Windows. De même, respecter les majuscules.) Pour savoir
où le trouver, on a dans le CMakeLists.txt :
find_package(Imagine)
ImagineUseModules(Mastermind Graphics)
10. Les pré-processeurs savent heureusement détecter ce cas de figure.
11. Notez que les commandes du préprocesseur ne se terminent pas par un point-virgule, mais avec
la fin de ligne.
86
6. Plusieurs fichiers ! 6.2. Opérateurs
La commande ImagineUseModules est spécifique à Imagine++ (d’où le find_package),

mais appelle include_directories en lui donnant comme chemin
<Imagine_DIR>/include
avec <Imagine_DIR> le chemin d’installation d’Imagine++.
6.2 Opérateurs
Le C++ permet de définir les opérateurs +, -, etc. quand les opérandes sont de nou-
veaux types. Voici très succinctement comment faire. Nous laissons au lecteur le soin
de découvrir seul quels sont les opérateurs qu’il est possible de définir.
Considérons l’exemple suivant qui définit un vecteur 12 2D et en implémente l’ad-
dition :
s t r u c t vect {
double x , y ;
};
v e c t plus ( v e c t m, v e c t n ) {
v e c t p={m. x+n . x ,m. y+n . y } ;
return p ;
}
i n t main ( ) {
vect a ={1 ,2} , b = { 3 , 4 } ;
v e c t c=plus ( a , b ) ;
return 0;
}
Voici comment définir le + entre deux vect et ainsi remplacer la fonction plus() :
s t r u c t vect {
double x , y ;
};
v e c t o p e r a t o r +( v e c t m, v e c t n ) {
v e c t p={m. x+n . x ,m. y+n . y } ;
return p ;
}
i n t main ( ) {
vect a ={1 ,2} , b = { 3 , 4 } ;
v e c t c=a+b ;
return 0;
}
Nous pouvons aussi définir un produit par un scalaire, un produit scalaire 13 , etc 14 .
12. Coin des collégiens : vous ne savez pas ce qu’est un vecteur. . . mais vous êtes plus forts en pro-
grammation que les "vieux". Alors regardez les sources qui suivent et vous saurez ce qu’est un vecteur
2D !
13. Dans ce cas, on utilise a*b et non a.b, le point n’étant pas définissable car réservé à l’accès aux
champs de la structure
14. On peut en fait définir ce qui existe déjà sur les types de base. Attention, il est impossible de
redéfinir les opérations des types de base ! Pas question de donner un sens différent à 1+1.
87
6.3. Récréation : TP suite et fin 6. Plusieurs fichiers !
/ / P r o d u i t p a r un s c a l a i r e
v e c t o p e r a t o r ∗ ( double s , v e c t m) {
v e c t p={ s ∗m. x , s ∗m. y } ;
return p ;
}
/ / Produit s c a l a i r e
double o p e r a t o r ∗ ( v e c t m, v e c t n ) {
r e t u r n m. x∗n . x+m. y∗n . y ;
}
i n t main ( ) {
vect a ={1 ,2} , b = { 3 , 4 } ;
v e c t c =2∗a ;
double s=a ∗b ;
return 0;
}
Remarquez que les deux fonctions ainsi définies sont différentes bien que de même
nom (operator∗) car elles prennent des paramètres différents (cf surcharge section 3.2.6).
6.3 Récréation : TP suite et fin
Le programme du TP précédent étant un exemple parfait de besoin de fichiers sépa-

rés (structures bien identifiées, partagées par deux projets), nous vous proposons, dans
le TP A.5 de convertir (et terminer ?) notre programme de simulation de gravitation et
de duel dans l’espace !
La fiche habituelle. . .
88
6. Plusieurs fichiers ! 6.4. Fiche de référence

Variables double x=12.3; — Combinaisons : && ||
— Définition : char c=’A’;
— if (i==0) j=1;
int i; string s="hop";
bool t=true; — if (i==0) j=1;
int k,l,m;
float y=1.2f; else j=2;
— Affectation : unsigned int j=4;
i=2; signed char d=-128;
j=i; — if (i==0) {
unsigned char d=25;
k=l=3; j=1;
complex<double>
k=2;
— Initialisation : z(2,3);
}
int n=5,o=n;
— Variables globales : — bool t=(i==0);
— Constantes : if (t)
const int s=12; int n;
const int m=12; j=1;
— Portée : void f() { — switch (i) {
int i; n=10; // OK case 1:
// i=j; interdit! int i=m; // OK ...;
int j=2; ... ...;
i=j; // OK! — Conversion : break;
if (j>1) { int i=int(x),j; case 2:
int k=3; float x=float(i)/j; case 3:
j=k; // OK! ...;
} Tests break;
//i=k; interdit! — Comparaison : default:
— Types : == != < > <= >= ...;
int i=3; — Négation : ! }
89
6.4. Fiche de référence 6. Plusieurs fichiers !

Boucles a=b;b=tmp; a.x=2.3; a.y=3.4;
— do { } a.c=Red;
... ... Point b={1,2.5,Blue};
} while(!ok); int x=3,y=2;
swap(x,y); Compilation séparée
— int i=1;
— Surcharge : — #include "vect.h", aussi
while(i<=100) {
int hasard(int n); dans vect.cpp
...
i=i+1; int hasard(int a, — Fonctions : déclarations dans
} int b); le .h, définitions dans le
double hasard(); .cpp
— for(int i=1;i<=10;i++)
... — Opérateurs : — Types : définitions dans le .h
vect operator+(
— for(int i=1,j=10;j>i; — Ne déclarer dans le .h que les
vect A,vect B) {
i=i+2,j=j-3) fonctions utiles.
...
...
} — #pragma once au début du
Fonctions ... fichier.
— Définition : vect C=A+B; — Ne pas trop découper. . .
int plus(int a,int b){
Tableaux Divers
int c=a+b;
return c; — Définition :
— i++;
} — double x[5],y[5]; i--;
void affiche(int a) { for(int i=0;i<5;i++) i-=2;
cout << a << endl; y[i]=2*x[i]; j+=3;
}
— const int n=5; — j=i%n; // Modulo
— Déclaration : int i[n],j[2*n];
int plus(int a,int b); — #include <cstdlib>
— Initialisation : ...
— Retour : int t[4]={1,2,3,4}; i=rand()%n;
int signe(double x) { string s[2]={"ab","c"}; x=rand()/
if (x<0) double(RAND_MAX);
— Affectation :
return -1;
int s[3]={1,2,3},t[3]; — #include <ctime>
if (x>0)
for (int i=0;i<3;i++) // Un seul appel
return 1;
t[i]=s[i]; srand((unsigned int)
return 0;
} — En paramètre : time(0));
void afficher(int x, — void init(int t[4]) { — #include <cmath>
int y) { for(int i=0;i<4;i++) double sqrt(double x);
if (x<0 || y<0) t[i]=0; double cos(double x);
return; } double sin(double x);
if (x>=w || y>=h) double acos(double x);
— void init(int t[],
return;
int n) { — #include <string>
DrawPoint(x,y,RED);
for(int i=0;i<n;i++) using namespace std;
}
t[i]=0; string s="hop";
— Appel : } char c=s[0];
int f(int a) { ... } int l=s.size();
int g() { ... } Structures
... — struct Point { Entrées/Sorties
int i=f(2),j=g(); double x,y; — #include <iostream>
— Références : Color c; using namespace std;
void swap(int& a, }; ...
int& b){ ... cout <<"I="<<i<<endl;
int tmp=a; Point a; cin >> i >> j;
90
6. Plusieurs fichiers ! 6.4. Fiche de référence

Erreurs fréquentes — int f()[4] { // NON! — Debug : F5
— Pas de définition de fonction int t[4];
— Step over : F10
dans une fonction ! ...
return t; // NON! — Step inside : F11
— int q=r=4; // NON! } — Indent : Ctrl+A,Ctrl+I
— if (i=2) // NON! int t[4]; t=f();
if i==2 // NON! — int s[3]={1,2,3},t[3]; Conseils
if (i==2) then // NON! t=s; // NON! — Nettoyer en quittant.
— for(int i=0,i<100,i++) — int t[2]; — Erreurs et warnings : cliquer.
// NON! t={1,2}; // NON! — Indenter.
— int f() {...} — struct Point { — Ne pas laisser de warning.
int i=f; // NON! double x,y;
} // NON! — Utiliser le debuggeur.
— double x=1/3; // NON!
— Point a; — Faire des fonctions.
int i,j;
x=i/j; // NON! a={1,2}; // NON! — Tableaux : pas pour transcrire
x=double(i/j); //NON! — #include "tp.cpp"//NON une formule mathématique !
— double x[10],y[10]; — Faire des structures.
for(int i=1;i<=10;i++) — Faire des fichiers séparés.
Imagine++
y[i]=2*x[i];//NON — Le .h doit suffire à l’utilisa-
— int n=5; teur (qui ne doit pas regarder
int t[n]; // NON Clavier le .cpp)
91
7. La mémoire
Chapitre 7
La mémoire
Il est grand temps de revenir sur la mémoire et son utilisation. Nous pourrons alors mieux
comprendre les variables locales, comment marche exactement l’appel d’une fonction, les fonc-
tions récursives, etc. Après cela, nous pourrons enfin utiliser des tableaux de taille variable
(sans pour autant rentrer vraiment dans la notion délicate de pointeur).
7.1 L’appel d’une fonction

Il s’agit là d’une nouvelle occasion pour vous de comprendre enfin ce qui se passe
dans un programme. . .
7.1.1 Exemple
Considérons le programme suivant :
3
4 void v e r i f i e ( i n t p , i n t q , i n t quo , i n t r e s ) {
5 i f ( re s <0 || re s >=q || q∗quo+ r e s ! = p )
6 cout << " Tiens , c ’ e s t b i z a r r e ! " << endl ;
7 }
8
9 i n t d i v i s e ( i n t a , i n t b , i n t& r ) {
10 int q ;
11 q=a/b ;
12 r=a−q∗b ;
13 verifie (a ,b,q, r );
14 return q ;
15 }
16 i n t main ( )
17 {
18 i n t num, denom ;
19 do {
7.1. L’appel d’une fonction 7. La mémoire
20 cout << " E n t r e z deux e n t i e r s p o s i t i f s : " ;

21 c i n >> num >> denom ;
22 } while (num<=0 || denom< = 0 ) ;
23 i n t quotient , r e s t e ;
24 q u o t i e n t = d i v i s e (num, denom , r e s t e ) ;
25 cout << num << " / " << denom << " = " << q u o t i e n t
26 << " ( I l r e s t e " << r e s t e << " ) " << endl ;
27 return 0;
28 }
Calculant le quotient et le reste d’une division entière, et vérifiant qu’ils sont corrects,
il n’est pas passionnant et surtout inutilement long (en fait, ce sont juste les lignes 11
et 12 qui font tout !). Il s’agit par contre d’un bon exemple pour illustrer notre propos.
Une bonne façon d’expliquer exhaustivement son déroulement est de remplir le ta-
bleau suivant, déjà rencontré au TP A.2. En ne mettant que les lignes où les variables
changent, en supposant que l’utilisateur rentre 23 et 3 au clavier, et en indiçant avec
des lettres les différentes étapes d’une même ligne 1 , cela donne :
Ligne num denom quotient reste a b r qd retd pv qv quo res
18 ? ?
21 23 3
23 23 3 ? ?
24a 23 3 ? ?
9 23 3 ? ? 23 3 [reste]
10 23 3 ? ? 23 3 [reste] ?
11 23 3 ? ? 23 3 [reste] 7
12 23 3 ? 2 23 3 [reste] 7
13a 23 3 ? 2 23 3 [reste] 7
4 23 3 ? 2 23 3 [reste] 7 23 3 7 2
5 23 3 ? 2 23 3 [reste] 7 23 3 7 2
7 23 3 ? 2 23 3 [reste] 7
13b 23 3 ? 2 23 3 [reste] 7
14 23 3 ? 2 23 3 [reste] 7 7
15 23 3 ? 2 7
24b 23 3 7 2 7
25 23 3 7 2
28
A posteriori, on constate qu’on a implicitement supposé que lorsque le programme

est en train d’exécuter divise () , la fonction main() et ses variables existent encore et
qu’elles attendent simplement la fin de divise () . Autrement dit :
Un appel de fonction est un mécanisme qui permet de partir exécuter mo-

mentanément cette fonction puis de retrouver la suite des instructions et les
variables qu’on avait provisoirement quittées.
Les fonctions s’appelant les unes les autres, on se retrouve avec des appels de fonc-
tions imbriqués les uns dans les autres : main() appelle divise () qui lui-même appelle
verifie () 2 . Plus précisément, cette imbrication est un empilement et on parle de pile
1. par exemple 24a et 24b
2. Et d’ailleurs main() a lui-même été appelé par une fonction a laquelle il renvoie un int.
94
7. La mémoire 7.1. L’appel d’une fonction
des appels. Pour mieux comprendre cette pile, nous allons utiliser le debuggeur. Avant
cela, précisons ce qu’un informaticien entend par pile.
Pile/File
— Une pile est une structure permettant de mémoriser des données dans laquelle
celles-ci s’empilent de telle sorte que celui qui est rangé en dernier dans la pile en
est extrait en premier. En anglais, une pile (stack) est aussi appelée LIFO (last in
first out 3 ). On y empile (push) et on y dépile (pop) les données. Par exemple, après
un push(1), un push(2) et un push(3), le premier pop() donnera 3, le deuxième
pop() donnera 2 et un dernier pop() donnera 1.
— Pour une file (en anglais queue), c’est la même chose mais le premier arrivé est
le premier sorti (FIFO). Par exemple, après un push(1), un push(2) et un push(3),
le premier pop() donnera 1, le deuxième pop() donnera 2 et un dernier pop()
donnera 3.
7.1.2 Pile des appels et débuggeur

Observons donc la figure 7.1 obtenue en lançant notre programme d’exemple sous
debuggeur. En regardant la partie gauche de chaque étape, nous pouvons voir la pile
des appels. La partie droite affiche le contenu des variables, paramètres et valeurs de
retour dont nous pouvons constater la cohérence avec le tableau précédent.
(a) Comme l’indique la pile des appels, nous sommes ligne 24 de la fonction main(),
qui se trouve être le seul élément de la pile (main est la fonction d’entrée du
programme). Vérifiez les variables et le fait qu’elles valent n’importe quoi (ici 0
pour quotient et 4197024 pour reste) tant qu’elles ne sont pas initialisées ou
affectées.
(b) Avançons en pas-à-pas détaillé (touche F11) jusqu’à la ligne 12. Nous sommes
dans la fonction divise () , q vient de valoir 7, et la ligne 24 de main() est descendue
d’un cran dans la pile des appels.
(c) Nous sommes maintenant à la ligne 5 dans verifie () . La pile des appels à un ni-
veau de plus, divise () est en attente à la ligne 13 et main() toujours en 24. Vérifiez
au passage que la variable q affichée est bien celle de verifie () , qui vaut 3 et non
pas celle de divise () .
(d) Ici, l’exécution du programme n’a pas progressé et nous en sommes toujours à
la ligne 5. Simplement, le debuggeur offre la possibilité en cliquant sur la pile
d’appel de regarder ce qui se passe à un des niveaux inférieurs, notamment pour
afficher les instructions et les variables de ce niveau. Ici, en cliquant sur la ligne
de divise () dans la fenêtre de la pile d’appel, nous voyons apparaître la ligne 13
et ses variables dans leur état alors que le programme est en 5. Entre autres, le
q affiché est celui de divise () et vaut 7.
(e) Toujours sans avancer, voici l’état du main() et de ses variables (entre autres, reste
est bien passé à 2 depuis la ligne 12 de divise () ).
3. Dernier rentré, premier sorti.
95
7.1. L’appel d’une fonction 7. La mémoire
(a)
(b)
(c)
(d)
(e)
(f)
(g)
F IGURE 7.1 – Appels de fontions
96
7. La mémoire 7.2. Variables Locales
pile variable valeur pile variable valeur pile variable valeur

place libre
top→ pv 23
place libre qv 3
quo 7
res 2 place libre
top→ a 23 a 23
b 3 b 3
qd 7 qd 7
r [reste] r [reste]
denom 3 denom 3 top→ denom 3
num 23 num 23 num 23
quotient ? quotient ? quotient 7
reste ? reste 2 reste 2
pris par les ... pris par les ... pris par les ...
fonctions ... fonctions ... fonctions ...
avant main ... avant main ... avant main ...
F IGURE 7.2 – Pile et variables locales. De gauche à droite : étape (b) (ligne 12), étape (c)
(ligne 5) et étape (g) (ligne 25/26).
(f) Nous exécutons maintenant la suite jusqu’à nous retrouver en ligne 24 au re-
tour de divise () . Pour cela, on peut faire du pas-à-pas détaillé, ou simplement
deux fois de suite un pas-à-pas sortant 4 (Maj-F11) pour relancer jusqu’à sortir de
verifie () , puis jusqu’à sortir de divise () . On voit bien quotient, qui est encore
non défini, et aussi la valeur de retour de divise () , non encore affectée à quotient.
(g) Un pas-à-pas de plus et nous sommes en 25/26. La variable quotient vaut enfin
7.
7.2 Variables Locales

Il va être important pour la suite de savoir comment les paramètres et les variables
locales sont stockés en mémoire.
7.2.1 Paramètres
Pour les paramètres, c’est simple :
Les paramètres sont en fait des variables locales ! Leur seule spécificité est
d’être initialisés dès le début de la fonction avec les valeurs passées à l’appel
de la fonction.
4. Step Out ou Maj-F11 ou . Notez aussi la possibilité de continuer le programme jusqu’à une
certaine ligne sans avoir besoin de mettre un point d’arrêt temporaire sur cette ligne mais simplement
en cliquant sur la ligne avec le bouton de droite et en choisissant "Run to line. . . ", ( )
97
7.3. Fonctions récursives 7. La mémoire
7.2.2 La pile
Les variables locales (et donc les paramètres) ne sont pas mémorisées à des adresses
fixes en mémoire 5 , décidées à la compilation. Si on faisait ça, les adresses mémoire
en question devraient être réservées pendant toute l’exécution du programme : on ne
pourrait y ranger les variables locales d’autres fonctions. La solution retenue est beau-
coup plus économe en mémoire 6 :
Les variables locales sont mémorisées dans un pile :

— Quand une variables locale est créée, elle est rajoutée en haut de cette
pile.
— Quand elle meurt (en général quand on quitte sa fonction) elle est sor-
tie de la pile.
Ainsi, au fur et à mesure des appels, les variables locales s’empilent : la mémoire est
utilisée juste pendant le temps nécessaire. La figure 7.2 montre trois étapes de la pile
pendant l’exécution de notre exemple.
7.3 Fonctions récursives

Un fonction récursive est une fonction qui s’appelle elle-même. La fonction la plus
classique pour illustrer la récursivité est la factorielle 7 . Voici une façon simple et récur-
sive de la programmer :
5 int fact1 ( int n)
6 {
7 i f ( n==1)
8 return 1;
9 r e t u r n n∗ f a c t 1 ( n − 1 ) ;
10 }
On remarque évidemment que les fonctions récursives contiennent (en général au dé-
but, et en tout cas avant l’appel récursif !) une condition d’arrêt : ici si n vaut 1, la fonction
retourne directement 1 sans s’appeler elle-même 8 .
7.3.1 Pourquoi ça marche ?

Si les fonctions avaient mémorisé leurs variables locales à des adresses fixes, la
récursivité n’aurait pas pu marcher : l’appel récursif aurait écrasé les valeurs des va-
riables. Par exemple, fact1 (3) aurait écrasé la valeur 3 mémorisée dans n par un 2 en
appelant fact1 (2) ! C’est justement grâce à la pile que le n de fact1 (2) n’est pas le même
que celui de fact1 (3). Ainsi, l’appel à fact1 (3) donne-t’il le tableau suivant :
5. Souvenons-nous du chapitre 2.
6. Et permettra de faire des fonctions récursives, cf section suivante !
7. Coin des collégiens : La factorielle d’un nombre entier n s’écrit n! et vaut n! = 1 × 2 × . . . × n.
8. Le fait de pouvoir mettre des return au milieu des fonctions est ici bien commode !
98
7. La mémoire 7.3. Fonctions récursives
Ligne nf act1(3) retf act1(3) nf act1(2) retf act1(2) nf act1(1) retf act1(1)
5f act1(3) 3
9af act1(3) 3
5f act1(2) 3 2
9af act1(2) 3 2
5f act1(1) 3 2 1
8f act1(1) 3 2 1 1
10f act1(1) 3 2 1
9bf act1(2) 3 2 2 1
10f act1(2) 3 2
9bf act1(3) 3 6 2
10f act1(3) 6
Ce tableau devient difficile à écrire maintenant qu’on sait que les variables locales ne
dépendent pas que de la fonction mais changent à chaque appel ! On est aussi obligé
de préciser, pour chaque numéro de ligne, quel appel de fonction est concerné. Si on
visualise la pile, on comprend mieux pourquoi ça marche. Ainsi, arrivés en ligne 8 de
fact1 (1) pour un appel initial à fact1 (3), la pile ressemble à :
pile variable valeur
place libre
top→ nf act1(1) 1
nf act1(2) 2
nf act1(3) 3
ce que l’on peut aisément vérifier avec le débuggeur. Finalement :
Les fonctions récursives ne sont pas différentes des autres. C’est le système
d’appel des fonctions en général qui rend la récursivité possible.
7.3.2 Efficacité
Une fonction récursive est simple et élégante à écrire quand le problème s’y prête 9 .
Nous venons de voir qu’elle n’est toujours pas facile à suivre ou à debugger. Il faut
aussi savoir que
la pile des appels n’est pas infinie et même relativement limitée.
Ainsi, le programme suivant
22 / / Fait déborder la pile
23 i n t fact3 ( int n)
24 {
25 i f ( n==1)
26 return 1;
27 r e t u r n n∗ f a c t 3 ( n + 1 ) ; / / e r r e u r !
28 }
dans lequel une erreur s’est glissée va s’appeler théoriquement à l’infini et en pratique
s’arrêtera avec une erreur de dépassement de la pile des appels 10 . Mais la vraie raison
qui fait qu’on évite parfois le récursif est qu’
9. C’est une erreur classique de débutant que de vouloir abuser du récursif.
10. Sous Linux, il s’arrête pour n = 260, 000 environ.
99
7.3. Fonctions récursives 7. La mémoire
appeler une fonction est un mécanisme coûteux !
Lorsque le corps d’une fonction est suffisamment petit pour que le fait d’appeler cette
fonction ne soit pas négligeable devant le temps passé à exécuter la fonction elle-même,
il est préférable d’éviter ce mécanisme d’appel 11 . Dans le cas d’une fonction récursive,
on essaie donc s’il est nécessaire d’écrire une version dérécursivée (ou itérative) de la
fonction. Pour notre factorielle, cela donne :
/ / Version i t é r a t i v e
int fact2 ( int n)
{
i n t f =1;
f o r ( i n t i = 2 ; i <=n ; i ++)
f ∗= i ;
return f ;
}
ce qui après tout n’est pas si terrible.
Enfin, il arrive qu’écrire une fonction sous forme récursive ne soit pas utilisable
pour des raisons de complexité. Une exemple classique est la suite de Fibonacci définie
par :
f0 = f1 = 1
fn = fn−1 + fn−2
et qui donne : 1, 1, 2, 3, 5, 8,. . . En version récursive :
32 / / T r è s l e n t !
33 i n t f i b 1 ( i n t n ) {
34 i f ( n <2)
35 return 1;
36 r e t u r n f i b 1 ( n−2)+ f i b 1 ( n − 1 ) ;
37 }
cette fonction a la mauvaise idée de s’appeler très souvent : n = 10 appelle n = 9
et n = 8, mais n = 9 appelle lui aussi n = 8 de son côté en plus de n = 7, n = 7
qui lui-même est appelé par tous les n = 8 lancés, etc. Bref, cette fonction devient
rapidement très lente. Ainsi, pour n = 40, elle s’appelle déjà 300.000.000 de fois elle-
même, ce qui prend un certain temps ! Il est donc raisonnable d’en programmer une
version dérécursivée :
39 / / Dérécursivée
40 i n t fib2 ( int n) {
41 i n t fnm2 =1 , fnm1 = 1 ;
42 f o r ( i n t i = 2 ; i <=n ; i ++) {
43 i n t fn=fnm2+fnm1 ;
44 fnm2=fnm1 ;
45 fnm1=fn ;
46 }
47 r e t u r n fnm1 ;
48 }
11. Nous verrons dans un autre chapitre les fonctions inline qui répondent à ce problème.
100
7. La mémoire 7.4. Le tas
Mentionnons aussi qu’il existe des fonctions suffisamment tordues pour que leur ver-
sion récursive ne se contente pas de s’appeler un grand nombre de fois en tout, mais
un grand nombre de fois en même temps, ce qui fait qu’indépendamment des questions
d’efficacité, leur version récursive fait déborder la pile d’appels !
7.4 Le tas
La pile n’est pas la seule zone de mémoire utilisée par les programmes. Il y a aussi
le tas (heap en anglais).
7.4.1 Limites
La pile est limitée en taille. La pile d’appel n’étant pas infinie et les variables locales
n’étant pas en nombre illimité, il est raisonnable de réserver une pile de relativement
petite taille. Essayez donc le programme :
32 i n t main ( )
33 {
34 const i n t n=500000;
35 int t [n ] ;
36 ...
37 }
Il s’exécute avec une erreur : "stack overflow". La variable locale t n’est pas trop grande
pour l’ordinateur 12 : elle est trop grande pour tenir dans la pile. Jusqu’à présent, on
savait qu’on était limité aux tableaux de taille constante. En réalité, on est aussi limité
aux petits tableaux. Il est donc grand temps d’apprendre à utiliser le tas !
7.4.2 Tableaux de taille variable

Nous fournissons ici une règle à appliquer en aveugle. Sa compréhension viendra plus tard
si nécessaire.
Lorsqu’on veut utiliser un tableau de taille variable, il n’y a que deux choses à faire,
mais elle sont essentielles toutes les deux 13 :
1. Remplacer int t[n] par int* t=new int[n] (ou l’équivalent pour
un autre type que int)
2. Lorsque le tableau doit mourir (en général en fin de fonction), rajouter
la ligne delete[] t;
Le non respect de la règle 2 fait que le tableau reste en mémoire jusqu’à la fin du pro-
gramme, ce qui entraine en général une croissance anarchique de la mémoire utilisée
(on parle de fuite de mémoire). Pour le reste, on ne change rien. Programmer un tableau
de cette façon fait qu’il est mémorisé dans le tas et non plus dans la pile. On fait donc
ainsi :
12. 500000x4 soit 2Mo seulement !
13. Et le débutant oublie toujours la deuxième, ce qui a pour conséquence des programmes qui gros-
sissent en quantité de mémoire occupée. . .
101
7.4. Le tas 7. La mémoire
1. Pour les tableaux de taille variable.

2. Pour les tableaux de grande taille.
Voici ce que cela donne sur un petit programme :
3
4 void r e m p l i t ( i n t t [ ] , i n t n )
5 {
6 f o r ( i n t i = 0 ; i <n ; i ++)
7 t [ i ]= i + 1 ;
8 }
9
10 i n t somme( i n t t [ ] , i n t n )
11 {
12 i n t s =0;
13 f o r ( i n t i = 0 ; i <n ; i ++)
14 s+= t [ i ] ;
15 return s ;
16 }
17
18 void f i x e ( )
19 {
20 const i n t n=5000;
21 int t [n ] ;
22 remplit ( t , n ) ;
23 i n t s=somme( t , n ) ;
24 cout << s << " d e v r a i t v a l o i r " << n ∗ ( n+1)/2 << endl ;
25 }
26
27 void v a r i a b l e ( )
28 {
29 int n;
30 cout << "Un e n t i e r SVP : " ;
31 c i n >> n ;
32 i n t ∗ t =new i n t [ n ] ; / / A l l o c a t i o n
33 remplit ( t , n ) ;
34 i n t s=somme( t , n ) ;
35 cout << s << " d e v r a i t v a l o i r " << n ∗ ( n+1)/2 << endl ;
36 delete [ ] t ; / / D e s a l l o c a t i o n : ne p a s o u b l i e r !
37 }
38
39 i n t main ( )
40 {
41 fixe ( ) ;
42 variable ( ) ;
43 return 0;
44 }
102
7. La mémoire 7.5. L’optimiseur
7.4.3 Essai d’explication
Ce qui suit n’est pas essentiel pour un débutant mais peut éventuellement répondre à ses
interrogations. S’il comprend, tant mieux, sinon, qu’il oublie et se contente pour l’instant de la
règle précédente !
Pour avoir accès à toute la mémoire de l’ordinateur 14 , on utilise le tas. Le tas est une
zone mémoire que le programme possède et qui peut croître s’il en fait la demande au
système d’exploitation (et s’il reste de la mémoire de libre évidemment). Pour utiliser le
tas, on appelle une fonction d’allocation à laquelle on demande de réserver en mémoire
de la place pour un certain nombre de variables. C’est ce que fait new int[n].
Cette fonction retourne l’adresse de l’emplacement mémoire qu’elle a réservé. Nous
n’avons jamais rencontré de type de variable capable de mémoriser une adresse. Il
s’agit des pointeurs dont nous reparlerons plus tard. Un pointeur vers de la mémoire
stockant des int est de type int∗. D’où le int∗ t pour mémoriser le retour du new.
Ensuite, un pointeur peut s’utiliser comme un tableau, y compris comme paramètre
d’une fonction.
Enfin, il ne faut pas oublier de libérer la mémoire au moment où le tableau de taille
constante aurait disparu : c’est ce que fait la fonction delete [] t qui libère la mémoire
pointée par t.
7.5 L’optimiseur
Mentionnons ici un point important qui était négligé jusqu’ici, mais que nous allons
utiliser en TP.
Il y a plusieurs façons de traduire en langage machine un source C++. Le résultat
de la compilation peut donc être différent d’un compilateur à l’autre. Au moment de
compiler, on peut aussi rechercher à produire un exécutable le plus rapide possible :
on dit que le compilateur optimise le code. En général, l’optimisation nécessite un plus
grand travail mais aussi des transformations qui font que le code produit n’est plus
facilement débuggable. On choisit donc en pratique entre un code debuggable et un
code optimisé.
Jusqu’ici, nous utilisions toujours le compilateur en mode "Debug". Lorsqu’un pro-
gramme est au point (et seulement lorsqu’il l’est), on peut basculer le compilateur en
mode "Release" pour avoir un programme plus performant. Dans certains cas, les gains
peuvent être considérables. Un programmeur expérimenté fait même en sorte que l’op-
timiseur puisse efficacement faire son travail. Ceci dit, il faut respecter certaines règles :
— Ne pas debugger quand on est en mode Release ( !)
— Rester en mode Debug le plus longtemps possible pour bien mettre au point le
programme.
14. Plus exactement à ce que le système d’exploitation veut bien attribuer au maximum à chaque pro-
gramme, ce qui est en général réglable mais en tout cas moins que la mémoire totale, bien que beaucoup
plus que la taille de la pile.
103
7.6. Assertions 7. La mémoire
7.6 Assertions
Voici une fonction très utile pour faire des programmes moins buggés ! La fonction
assert () prévient quand un test est faux. Elle précise le fichier et le numéro de ligne où
elle se trouve, offre la possibilité de debugger le programme, etc. Elle ne ralentit pas
les programmes car elle disparaît à la compilation en mode Release. C’est une fonction
peu connue des débutants, et c’est bien dommage ! Par exemple :
# include <cassert >

...
int n;
c i n >> n ;
assert (n>0);
i n t ∗ t =new i n t [ n ] ; // Allocation
Si l’utilisateur entre une valeur négative, les conséquences pourraient être fâcheuses.
En particulier une valeur négative de n serait interprétée comme un grand entier (car le
[] attend un entier non signé, ainsi -1 serait compris comme le plus grand int possible)
et le new serait probablement un échec. A noter que si n==0, un tableau nul, l’allocation
marche. Mais dans ce cas t [0] n’existe même pas ! La seule chose qu’on peut donc
faire avec un tableau nul c’est le désallouer avec delete [] t ;. Il est toujours utile de se
prémunir contre une telle exception en vérifiant que la valeur est raisonnable.
7.7 Tableaux bidimensionnels

Anticipons légèrement sur le prochain chapitre avec les tableaux à deux dimen-
sions. Si m et n sont des constantes, on peut avoir un tableau tab[m][n], qu’il est même
possible de mettre dans une structure :
c o n s t i n t m=5 , n = 3 ;
s t r u c t Tableau { double t a b [m] [ n ] ; } ;
void f ( Tableau& t ) {
f o r ( i n t i = 0 ; i <m; i ++)
f o r ( i n t j = 0 ; j <n ; j ++)
t . t a b [ i ] [ j ] = cos ( M_PI∗ i /m) ∗ s i n ( M_PI∗ j /n ) ;
cout << t . t a b [m−1][n−1] << endl ;
}
Notons le double crochet pour accéder à un élément, et bien sûr que le premier élement
est tab [0][0] et le dernier élément tab[m−1][n−1].
7.8 Examens sur machine

Nous vous conseillons aussi de vous confronter aux examens proposés sur le site
du cours. Vous avez toutes les connaissances nécessaires.
104
7. La mémoire 7.9. Fiche de référence

Variables — Comparaison : void affiche(int a) {
== != < > <= >= cout << a << endl;
— Définition :
— Négation : ! }
int i;
int k,l,m; — Combinaisons : && || — Déclaration :
int plus(int a,int b);
— Affectation : — if (i==0) j=1;
i=2; — Retour :
— if (i==0) j=1;
j=i; int signe(double x) {
else j=2;
k=l=3; if (x<0)
return -1;
— Initialisation : — if (i==0) { if (x>0)
int n=5,o=n; j=1; return 1;
— Constantes : k=2; return 0;
const int s=12; } }
— bool t=(i==0); void afficher(int x,
— Portée :
if (t) int y) {
int i;
j=1; if (x<0 || y<0)
// i=j; interdit!
— switch (i) { return;
int j=2;
case 1: if (x>=w || y>=h)
i=j; // OK!
...; return;
if (j>1) {
...; DrawPoint(x,y,RED);
int k=3;
break; }
j=k; // OK!
} case 2: — Appel :
//i=k; interdit! case 3: int f(int a) { ... }
...; int g() { ... }
— Types : break; ...
int i=3; default: int i=f(2),j=g();
double x=12.3; ...;
char c=’A’; — Références :
} void swap(int& a,
string s="hop";
bool t=true; Boucles int& b){
float y=1.2f; int tmp=a;
— do { a=b;b=tmp;
unsigned int j=4; ...
signed char d=-128; }
} while(!ok); ...
unsigned char d=25;
complex<double> — int i=1; int x=3,y=2;
z(2,3); while(i<=100) { swap(x,y);
...
— Surcharge :
i=i+1;
— Variables globales : int hasard(int n);
}
int n; int hasard(int a,
— for(int i=1;i<=10;i++) int b);
const int m=12;
... double hasard();
void f() {
n=10; // OK — for(int i=1,j=10;j>i; — Opérateurs :
int i=m; // OK i=i+2,j=j-3) vect operator+(
... ... vect A,vect B) {
Fonctions ...
— Conversion :
}
int i=int(x),j; — Définition : ...
float x=float(i)/j; int plus(int a,int b){ vect C=A+B;
— Pile/Tas int c=a+b;
return c; — Pile des appels
Tests } — Itératif/Récursif
105
7.9. Fiche de référence 7. La mémoire

Tableaux — i++; — double x=1/3; // NON!
— Définition : i--; int i,j;
i-=2; x=i/j; // NON!
— double x[5],y[5];
j+=3; x=double(i/j); //NON!
for(int i=0;i<5;i++)
y[i]=2*x[i]; — j=i%n; // Modulo — double x[10],y[10];
— #include <cstdlib> for(int i=1;i<=10;i++)
— const int n=5;
... y[i]=2*x[i];//NON
int i[n],j[2*n];
i=rand()%n; — int n=5;
x=rand()/ int t[n]; // NON
int t[4]={1,2,3,4};
double(RAND_MAX);
string s[2]={"ab","c"}; — int f()[4] { // NON!
— #include <ctime> int t[4];
— Affectation :
// Un seul appel ...
int s[3]={1,2,3},t[3];
srand((unsigned int) return t; // NON!
time(0)); }
t[i]=s[i];
— #include <cmath> int t[4]; t=f();
— En paramètre :
double sqrt(double x); — int s[3]={1,2,3},t[3];
— void init(int t[4]) { double cos(double x); t=s; // NON!
for(int i=0;i<4;i++) double sin(double x);
t[i]=0; double acos(double x); — int t[2];
} t={1,2}; // NON!
— #include <string>
— void init(int t[], using namespace std; — struct Point {
int n) { string s="hop"; double x,y;
for(int i=0;i<n;i++) char c=s[0]; } // NON!
t[i]=0; int l=s.size(); — Point a;
} a={1,2}; // NON!
— #include <ctime>
— Taille variable : s=double(clock()) — #include "tp.cpp"//NON
int* t=new int[n]; /CLOCKS_PER_SEC;
... Imagine++
delete[] t; Entrées/Sorties
Structures — #include <iostream>
using namespace std; Conseils
— struct Point { ... — Nettoyer en quittant.
double x,y; cout <<"I="<<i<<endl;
Color c; — Erreurs et warnings : cliquer.
cin >> i >> j;
}; — Indenter.
... Clavier
— Ne pas laisser de warning.
Point a; — Debug : F5
a.x=2.3; a.y=3.4; — Utiliser le debuggeur.
a.c=Red; — Step over : F10
— Faire des fonctions.
Point b={1,2.5,Blue}; — Step inside : F11 — Tableaux : pas pour transcrire
Compilation séparée — Indent : Ctrl+A,Ctrl+I une formule mathématique !
— #include "vect.h", aussi — Step out : Maj+F11 — Faire des structures.
dans vect.cpp — Faire des fichiers séparés.
Erreurs fréquentes
— Fonctions : déclarations dans
— Le .h doit suffire à l’utilisa-
le .h, définitions dans le — Pas de définition de fonction
dans une fonction ! teur (qui ne doit pas regarder
.cpp
le .cpp)
— Types : définitions dans le .h — int q=r=4; // NON!
— Ne pas abuser du récursif.
— Ne déclarer dans le .h que les — if (i=2) // NON!
fonctions utiles. if i==2 // NON! — Ne pas oublier delete.
if (i==2) then // NON! — Compiler régulièrement.
— #pragma once au début du
fichier. — for(int i=0,i<100,i++) — #include <cassert>
// NON! ...
— Ne pas trop découper. . .
— int f() {...} assert(x!=0);
Divers int i=f; // NON! y=1/x;
106
8. Allocation dynamique
Chapitre 8
Allocation dynamique
Nous revenons une fois de plus sur l’utilisation du tas pour gérer des tableaux de taille
variable. Après avoir mentionné l’existence de tableaux bidimensionnels de taille fixe, nous dé-
taillons l’allocation dynamique 1 déjà vue en 7.4.2 et expliquons enfin les pointeurs, du moins
partiellement. A travers l’exemple des matrices (et des images en TP) nous mélangeons struc-
tures et allocation dynamique. Il s’agira là de notre structure de donnée la plus complexe avant
l’arrivée tant attendue - et maintenant justifiée - des objets. . .
8.1 Tableaux bidimensionnels

8.1.1 Principe
Il existe en C++ des tableaux à deux dimensions. Leur utilisation est similaire à celle
des tableaux standards :
— Il faut utiliser des crochets (lignes 1 et 4 du programme ci-dessous). Attention :
[ i ][ j ] et non [ i , j ].
— L’initialisation est possible avec des accolades (ligne 5). Attention : accolades im-
briquées.
— Leurs dimensions doivent être constantes (lignes 6 et 7).
1 i n t A[ 2 ] [ 3 ] ; B[0] 1 2 3
2 f o r ( i n t i = 0 ; i < 2 ; i ++)
3 f o r ( i n t j = 0 ; j < 3 ; j ++)
4 A[ i ] [ j ]= i + j ; B[1] 4 5 6
5 int B[2][3]={{1 ,2 ,3} ,{4 ,5 ,6}};
6 c o n s t i n t M=2 ,N= 3 ; Tableau 2D. Notez que B[0] est
7 i n t C[M] [N] ; le tableau 1D {1,2,3} et B[1] le
tableau 1D {4,5,6} .
La figure ci-dessus montre le tableau B. À noter que B[0] et B[1] sont des tableaux
1D représentant les lignes de B.
1. c’est-à-dire l’allocation de mémoire dans le tas avec new et delete.

8.1. Tableaux bidimensionnels 8. Allocation dynamique
8.1.2 Limitations
Vis-à-vis des fonctions, les particularités sont les mêmes qu’en 1D :
— Impossible de retourner un tableau 2D.
— Passage uniquement par variable.
mais avec une restriction supplémentaire :
On est obligé de préciser les dimensions d’un tableau 2D paramètre de fonc-

tion.
Impossible donc de programmer des fonctions qui peuvent travailler sur des tableaux
de différentes tailles comme dans le cas 1D (cf 4.3.1). C’est très restrictif et explique
que les tableaux 2D ne sont pas toujours utilisés. On peut donc avoir le programme
suivant :
1 / / Passage de paramètre
2 double t r a c e ( double A [ 2 ] [ 2 ] ) {
3 double t = 0 ;
4 f o r ( i n t i = 0 ; i < 2 ; i ++)
5 t +=A[ i ] [ i ] ;
6 return t ;
7 }
8
9 / / Le p a s s a g e e s t t o u j o u r s p a r r é f é r e n c e . . .
10 void s e t ( double A [ 2 ] [ 3 ] ) {
11 f o r ( i n t i = 0 ; i < 2 ; i ++)
12 f o r ( i n t j = 0 ; j < 3 ; j ++)
13 A[ i ] [ j ]= i + j ;
14 }
15
16 ...
17 double D[ 2 ] [ 2 ] = { { 1 , 2 } , { 3 , 4 } } ;
18 double t = t r a c e (D ) ;
19 double E [ 2 ] [ 3 ] ;
20 set (E ) ;
21 ...
mais il est impossible de programmer une fonction trace () ou set () qui marche pour
différentes tailles de tableaux 2D comme on l’aurait fait en 1D :
1 / / OK
2 void s e t ( double A[ ] , i n t n , double x ) {
3 f o r ( i n t i = 0 ; i <n ; i ++)
4 A[ i ]= x ;
5 }
6 / / NON ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
7 / / double A[ ] [ ] est refusé
8 void s e t ( double A [ ] [ ] , double m, double n , double x ) {
9 f o r ( i n t i = 0 ; i <m; i ++)
10 f o r ( i n t j = 0 ; j <n ; j ++)
108
8. Allocation dynamique 8.1. Tableaux bidimensionnels
B[0]=1 B[2]=2 B[4]=3
B[1]=4 B[3]=5 B[5]=6
F IGURE 8.1 – La matrice B de l’exemple précédent stockée en 1D.
11 A[ i ] [ j ]= x ;
12 }
8.1.3 Solution
En pratique, dès que l’on doit manipuler des tableaux de dimension 2 (ou plus !) de
différentes tailles, on les mémorise dans des tableaux 1D en stockant par exemple les
colonnes les unes après les autres pour profiter des avantages des tableaux 1D. Ainsi,
on stockera une matrice A de m lignes de n colonnes dans un tableau T de taille mn
en plaçant l’élément A(i, j) en T (i + mj). La Fig. 8.1 montre le tableau B de l’exemple
précédent stocké comme tableau 1D. On peut alors écrire :
1 void s e t ( double A[ ] , i n t m, i n t n ) {
2 f o r ( i n t i = 0 ; i <m; i ++)
3 f o r ( i n t j = 0 ; j <n ; j ++)
4 A[ i +m∗ j ]= i + j ;
5 }
6 ...
7 double F [ 2 ∗ 3 ] ;
8 set (F , 2 , 3 ) ;
9 double G[ 3 ∗ 5 ] ;
10 s e t (G, 3 , 5 ) ;
ou par exemple, ce produit matrice vecteur dans lequel les vecteurs et les matrices sont
stockés dans des tableaux 1D :
1 / / y=Ax
2 void p r o d u i t ( double A[ ] , i n t m, i n t n , double x [ ] , double y [ ] )
3 {
4 f o r ( i n t i = 0 ; i <m; i ++) {
5 y[ i ]=0;
6 f o r ( i n t j = 0 ; j <n ; j ++)
7 y [ i ]+=A[ i +m∗ j ] ∗ x [ j ] ;
8 }
9 }
10
11 ...
12 double P [ 2 ∗ 3 ] , x [ 3 ] , y [ 2 ] ;
13 ...
109
8.2. Allocation dynamique 8. Allocation dynamique
14 // P=... x=...
15 produit (P , 2 , 3 , x , y ) ; / / y=Px
8.2 Allocation dynamique

Il n’y a pas d’allocation dynamique possible pour les tableaux 2D. Il faut donc vrai-
ment les mémoriser dans des tableaux 1D comme expliqué ci-dessus pour pouvoir les
allouer dynamiquement dans le tas. L’exemple suivant montre comment faire. Il utilise
la fonction produit() donnée ci-dessus sans qu’il soit besoin de la redéfinir :
1 i n t m, n ;
2 ...
3 double ∗ A=new double [m∗n ] ;
4 double ∗ x=new double [ n ] ;
5 double ∗ y=new double [m] ;
6 ...
7 / / A= . . . x = . . .
8 p r o d u i t (A,m, n , x , y ) ; / / y=Ax
9 ...
10 d e l e t e [ ] A;
11 delete [ ] x ;
12 delete [ ] y ;
8.2.1 Pourquoi ça marche ?

Il est maintenant temps d’expliquer pourquoi, une fois alloués, nous pouvons utili-
ser des tableaux dynamiques exactement comme des tableaux de taille fixe. Il suffit de
comprendre les étapes suivantes :
1. int t [n] définit une variable locale, donc de la mémoire dans la pile, capable de
stocker n variables int.
2. int∗ t définit une variable de type "pointeur" d’int, c’est-à-dire que t peut mé-
moriser l’adresse d’une zone mémoire contenant des int.
3. new int[n] alloue dans le tas une zone mémoire pouvant stocker n int et renvoie
l’adresse de cette zone. D’où le int∗ t=new int[n]
4. delete [] t libère dans le tas l’adresse mémorisée dans t.
5. Lorsque t est un tableau de taille fixe t [ i ] désigne son i me élément. Lorsque t
est un pointeur d’int, t [ i ] désigne la variable int stockée i places 2 plus loin en
mémoire que celle située à l’adresse t. Ainsi, après un int t [n] comme après un
int∗ t=new int[n], la syntaxe t [ i ] désigne bien ce qu’on veut.
6. Lorsque t est un tableau de taille fixe, la syntaxe t tout court désigne l’adresse
(dans la pile) à laquelle le tableau est mémorisé. De plus, lorsqu’une fonction
prend un tableau comme paramètre, la syntaxe int s [] signifie en réalité que s
est l’adresse du tableau. Ce qui fait qu’en fin de compte :
2. Ici, une place est évidemment le nombre d’octets nécessaires au stockage d’un int.
110
8. Allocation dynamique 8.2. Allocation dynamique
— une fonction f ( int s []) est conçue pour qu’on lui passe une adresse s
— elle marche évidemment avec les tableaux alloués dynamiquement qui ne
sont finalement que des adresses
— c’est plutôt l’appel f ( t ), avec t tableau de taille fixe, qui s’adapte en passant
à f l’adresse où se trouve le tableau.
— logiquement, on devrait même déclarer f par f ( int∗ s) au lieu de f ( int s []) .
Les deux sont en fait possibles et synonymes.
Vous pouvez donc maintenant programmer, en comprenant, ce genre de choses :
1 double somme( double ∗ t , i n t n ) { / / S y n t a x e " p o i n t e u r "
2 double s = 0 ;
3 f o r ( i n t i = 0 ; i <n ; i ++)
4 s+= t [ i ] ;
5 return s ;
6 }
7 ...
8 int t1 [ 4 ] ;
9 ...
10 double s1=somme( t1 , 4 ) ;
11 ...
12 i n t ∗ t 2 =new i n t [ n ] ;
13 ...
14 double s2=somme( t2 , n ) ;
15 ...
16 delete [ ] t2 ;
8.2.2 Erreurs classiques

Vous comprenez maintenant aussi les erreurs classiques suivantes (que vous n’évi-
terez pas pour autant !).
1. Oublier d’allouer :
int ∗t ;
f o r ( i n t i = 0 ; i <n ; i ++)
t[ i ]=... / / Horreur : t vaut n ’ importe
/ / q u o i comme a d r e s s e
2. Oublier de désallouer :
void f ( i n t n ) {
i n t ∗ t =new i n t [ n ] ;
...
} / / On o u b l i e d e l e t e [ ] t ;
/ / Chaque a p p e l à f ( ) va p e r d r e n i n t d a n s l e t a s !
3. Ne pas désallouer ce qu’il faut :

i n t ∗ t =new i n t [ n ] ;
i n t ∗ s=new i n t [ n ] ;
111
8.2. Allocation dynamique 8. Allocation dynamique
...
s= t ; / / A i e ! Du coup , s c o n t i e n t l a même a d r e s s e que t
/ / (On n ’ a p a s r e c o p i é l a z o n e p o i n t é e p a r t d a n s c e l l e
// p o i n t é e par s ! )
...
d e l e t e [ ] t ; / / OK
d e l e t e [ ] s ; / / C a t a : Non s e u l e m e n t on ne l i b è r e p a s l a mémoire
/ / i n i t i a l e m e n t m é m o r i s é e d a n s s , m a i s en p l u s on
/ / d é s a l l o u e à nouveau c e l l e q u i v i e n t d ’ ê t r e l i b é r é e !
8.2.3 Conséquences
Quand libérer ?
Maintenant que vous avez compris new et delete, vous imaginez bien qu’on n’at-
tend pas toujours la fin de l’existence du tableau pour libérer la mémoire. Le plus tôt
est le mieux et on libère la mémoire dès que le tableau n’est plus utilisé :
1 void f ( ) {
2 int t [10];
3 i n t ∗ s=new int [n ] ;
4 ...
5 delete [ ] s ; / / s i s ne s e r t p l u s d a n s l a s u i t e . . .
6 / / Autant l i b é r e r m a i n t e n a n t . . .
7 ...
8 } / / Par c o n t r e , t a t t e n d c e t t e l i g n e pour mourir .
En fait, le tableau dont l’adresse est mémorisée dans s est alloué ligne 3 et libéré ligne
5. La variable s qui mémorise son adresse, elle, est créée ligne 3 et meurt ligne 8 !
Pointeurs et fonctions
Il est fréquent que le new et le delete ne se fassent pas dans la même fonction (atten-
tion, du coup, aux oublis !). Ils sont souvent intégrés dans des fonctions. A ce propos,
lorsque des fonctions manipulent des variables de type pointeur, un certain nombre de
questions peuvent se poser. Il suffit de respecter la logique :
— Une fonction qui retourne un pointeur se déclare int∗ f ();
1 int ∗ alloue ( int n) {
2 r e t u r n new i n t [ n ] ;
3 }
4 ....
5 int ∗ t=alloue ( 1 0 ) ;
6 ...
— Un pointeur passé en paramètre à une fonction l’est par valeur. Ne pas mélan-
ger avec le fait qu’un tableau est passé par référence ! Considérez le programme
suivant :
1 void f ( i n t ∗ t , i n t n ) {
112
8. Allocation dynamique 8.3. Structures et allocation dynamique
2 ....
3 t [ i ] = . . . ; / / On m o d i f i e t [ i ] m a i s p a s t !
4 t = . . . / / Une t e l l e l i g n e ne c h a n g e r a i t p a s ’ s ’
5 / / dans l a f o n c t i o n a p p e l a n t e
6 }
7 ...
8 i n t ∗ s=new i n t [m] ;
9 f ( s ,m) ;
En fait, c’est parce qu’on passe l’adresse d’un tableau qu’on peut modifier ses élé-
ments. Par ignorance, nous disions que les tableaux étaient passés par référence
en annonçant cela comme une exception. Nous pouvons maintenant rectifier :
Un tableau est en fait passé via son adresse. Cette adresse est passée par
valeur. Mais ce mécanisme permet à la fonction appelée de modifier le
tableau. Dire qu’un tableau est passé par référence était un abus de
langage simplificateur.
— Si on veut vraiment passer le pointeur par référence, la syntaxe est logique :

int∗& t. Un cas typique de besoin est :
1 / / t et n seront modifiés ( et plus seulement t [ i ] )
2 void a l l o u e ( i n t ∗& t , i n t& n ) {
3 c i n >> n ; / / n e s t c h o i s i au c l a v i e r
4 t =new i n t [ n ] ;
5 }
6 ...
7 int ∗ t ;
8 int n;
9 alloue ( t , n ) ; / / t e t n sont a f f e c t é s par a l l o u e ( )
10 ...
11 d e l e t e [ ] t ; / / Ne p a s o u b l i e r p o u r a u t a n t !
Bizzarerie ? Les lignes 7 et 8 ci-dessus auraient pu s’écrire int∗ t ,n;. En fait, il faut
remettre une étoile devant chaque variable lorsqu’on définit plusieurs pointeurs en
même-temps. Ainsi, int ∗t , s,∗u; définit deux pointeurs d’int (les variables t et u) et
un int (la variable s).
8.3 Structures et allocation dynamique

Passer systématiquement un tableau et sa taille à toutes les fonctions est évidem-
ment pénible. Il faut les réunir dans une structure. Je vous laisse méditer l’exemple
suivant qui pourrait être un passage d’un programme implémentant des matrices 3 et
leur produit :
3. Coin des enfants : les matrices et les vecteurs vous sont inconnus. Ca n’est pas grave. Comprenez
le source quand même et rattrapez vous avec le TP qui, lui, joue avec des images.
113
8.3. Structures et allocation dynamique 8. Allocation dynamique
2 # include <string >
4
5 / / ==================================================
6 / / f o n c t i o n s sur l e s m a t r i c e s
7 / / p o u r r a i e n t e t r e d a n s un m a t r i c e . h e t un m a t r i c e . cpp
8
9 s t r u c t Matrice {
10 i n t m, n ;
11 double ∗ t ;
12 };
13
14 M a t r i c e c r e e ( i n t m, i n t n ) {
15 M a t r i c e M;
16 M.m=m;
17 M. n=n ;
18 M. t =new double [m∗n ] ;
19 r e t u r n M;
20 }
21
22 void d e t r u i t ( M a t r i c e M) {
23 d e l e t e [ ] M. t ;
24 }
25
26 M a t r i c e p r o d u i t ( M a t r i c e A, M a t r i c e B ) {
27 i f (A. n ! =B .m) {
28 cout << " E r r e u r ! " << endl ;
29 exit (1);
30 }
31 M a t r i c e C= c r e e (A.m, B . n ) ;
32 f o r ( i n t i = 0 ; i <A.m; i ++)
33 f o r ( i n t j = 0 ; j <B . n ; j ++) {
34 / / C i j =Ai0 ∗ B 0 j+Ai1 ∗ B 1 j + . . .
35 C . t [ i +C .m∗ j ] = 0 ;
36 f o r ( i n t k = 0 ; k<A. n ; k++)
37 C . t [ i +C .m∗ j ]+=A. t [ i +A.m∗k ] ∗ B . t [ k+B .m∗ j ] ;
38
39 }
40 return C;
41 }
42
43 void a f f i c h e ( s t r i n g s , M a t r i c e M) {
44 cout << s << " = " << endl ;
45 f o r ( i n t i = 0 ; i <M.m; i ++) {
46 f o r ( i n t j = 0 ; j <M. n ; j ++)
47 cout << M. t [ i +M.m∗ j ] << " " ;
48 cout << endl ;
114
8. Allocation dynamique 8.3. Structures et allocation dynamique
49 }
50 }
51
52 / / ==================================================
53 // Utilisateur
54
55 i n t main ( )
56 {
57 M a t r i c e A= c r e e ( 2 , 3 ) ;
58 f o r ( i n t i = 0 ; i < 2 ; i ++)
59 f o r ( i n t j = 0 ; j < 3 ; j ++)
60 A. t [ i +2∗ j ]= i + j ;
61 a f f i c h e ( "A" ,A ) ;
62 M a t r i c e B= c r e e ( 3 , 5 ) ;
63 f o r ( i n t i = 0 ; i < 3 ; i ++)
64 f o r ( i n t j = 0 ; j < 5 ; j ++)
65 B . t [ i +3∗ j ]= i + j ;
66 a f f i c h e ( "B" ,B ) ;
67 M a t r i c e C= p r o d u i t (A, B ) ;
68 a f f i c h e ( "C" ,C ) ;
69 d e t r u i t (C ) ;
70 detruit (B ) ;
71 d e t r u i t (A ) ;
72 return 0;
73 }
L’utilisateur n’a maintenant plus qu’à savoir qu’il faut allouer et libérer les matrices
en appelant des fonctions mais il n’a pas à savoir ce que font ces fonctions. Dans cette
logique, on pourra rajouter des fonctions pour qu’il n’ait pas non plus besoin de savoir
comment les éléments de la matrice sont mémorisés. Il n’a alors même plus besoin de
savoir que les matrices sont des structures qui ont un champ t ! (Nous nous rappro-
chons vraiment de la programmation objet. . . ) Bref, on rajoutera en général :
10 double g e t ( M a t r i c e M, i n t i , i n t j ) {
11 r e t u r n M. t [ i +M.m∗ j ] ;
12 }
13
14 void s e t ( M a t r i c e M, i n t i , i n t j , double x ) {
15 M. t [ i +M.m∗ j ]= x ;
16 }
que l’utilisateur pourra appeler ainsi :
51 f o r ( i n t i = 0 ; i < 2 ; i ++)
52 f o r ( i n t j = 0 ; j < 3 ; j ++)
53 s e t (A, i , j , i + j ) ;
et que celui qui programme les matrices pourra aussi utiliser pour lui :
39 void a f f i c h e ( s t r i n g s , M a t r i c e M) {
40 cout << s << " = " << endl ;
41 f o r ( i n t i = 0 ; i <M.m; i ++) {
115
8.4. Boucles et continue 8. Allocation dynamique
A.t ... A.t ... A.t ... A.t ...
B.t ... B.t ... B.t ... B.t ...
A=cree(2,3); A=B; detruit(A); detruit(B);

B=cree(2,3);
F IGURE 8.2 – Attention au double delete : le code A=B fait pointer deux fois sur la
même zone mémoire alors qu’il n’y a plus de pointeur sur le tableau du haut (donc
une fuite mémoire puisqu’il n’est plus possible de la libérer). Le detruit(B) libère
une zone mémoire qui l’avait déjà été, avec des conséquences fâcheuses. . .
42 f o r ( i n t j = 0 ; j <M. n ; j ++)
43 cout << g e t (M, i , j ) << " " ;
44 cout << endl ;
45 }
46 }
Attention, il reste facile dans ce contexte :
— D’oublier d’allouer.
— D’oublier de désallouer.
— De ne pas désallouer ce qu’il faut si on fait A=B entre deux matrices. (C’est alors
deux fois la zone allouée initialement pour B qui est désallouée lorsqu’on libère
A et B tandis que la mémoire initiale de A ne le sera jamais, comme on peut le
voir sur la Fig. 8.2).
La programmation objet essaiera de faire en sorte qu’on ne puisse plus faire ces erreurs.
Elle essaiera aussi de faire en sorte que l’utilisateur ne puisse plus savoir ce qu’il n’a pas
besoin de savoir, de façon à rendre vraiment indépendantes la conception des matrices
et leur utilisation.
8.4 Boucles et continue

Nous utiliserons dans le TP l’instruction continue qui est bien pratique. Voici ce
qu’elle fait : lorsqu’on la rencontre dans une boucle, toute la fin de la boucle est sautée
et on passe au tour suivant. Ainsi :
for ( . . . ) {
...
i f (A)
continue ;
...
i f (B)
continue ;
...
}
est équivalent à (et remplace avantageusement au niveau clarté et mise en page) :
for ( . . . ) {
...
116
8. Allocation dynamique 8.5. TP
i f ( ! A) {
...
i f ( ! B) {
...
}
}
}
Ceci est à rapprocher de l’utilisation du return en milieu de fonction pour évacuer les
cas particuliers (section 7.3).
F IGURE 8.3 – Deux images et différents traitements de la deuxième (négatif, flou, relief,
déformation, contraste et contours).
8.5 TP
Le TP que nous proposons en A.7 est une illustration de cette façon de manipuler
des tableaux bidimensionnels dynamiques à travers des structures de données. Pour
changer de nos passionnantes matrices, nous travaillerons avec des images (figure 8.3).

Boucles i=i+1; — for (int i=...)
— do { } for (int j=...) {
... — for(int i=1;i<=10;i++) //saute cas i==j
} while(!ok); ... if (i==j)
— int i=1; — for(int i=1,j=10;j>i; continue;
while(i<=100) { i=i+2,j=j-3) ...
... ... }
117
8.6. Fiche de référence 8. Allocation dynamique

Variables a=b;b=tmp;
— Définition : Clavier }
int i; — Debug : F5 ...
int k,l,m; int x=3,y=2;
— Step over : F10 swap(x,y);
— Affectation :
i=2; — Step inside : F11 — Surcharge :
j=i; — Indent : Ctrl+A,Ctrl+I int hasard(int n);
k=l=3; — Step out : Maj+F11 int hasard(int a,
— Initialisation : int b);
— Gest. tâches : Ctrl+Maj+Ech double hasard();
int n=5,o=n;
— Constantes : Fonctions — Opérateurs :
const int s=12; — Définition : vect operator+(
int plus(int a,int b){ vect A,vect B) {
— Portée :
int c=a+b; ...
int i;
return c; }
// i=j; interdit!
} ...
int j=2;
void affiche(int a) { vect C=A+B;
i=j; // OK!
if (j>1) { cout << a << endl; — Pile des appels
int k=3; } — Itératif/Récursif
j=k; // OK! — Déclaration :
} int plus(int a,int b); Tableaux
//i=k; interdit! — Retour : — Définition :
— Types : int signe(double x) { — double x[5],y[5];
int i=3; if (x<0) for(int i=0;i<5;i++)
double x=12.3; return -1; y[i]=2*x[i];
char c=’A’; if (x>0)
string s="hop"; return 1; — const int n=5;
bool t=true; return 0; int i[n],j[2*n];
float y=1.2f; } — Initialisation :
unsigned int j=4; void afficher(int x, int t[4]={1,2,3,4};
signed char d=-128; int y) { string s[2]={"ab","c"};
unsigned char d=25; if (x<0 || y<0)
complex<double> — Affectation :
return;
z(2,3); int s[3]={1,2,3},t[3];
if (x>=w || y>=h)
return;
t[i]=s[i];
— Variables globales : DrawPoint(x,y,RED);
int n; } — En paramètre :
const int m=12; — Appel : — void init(int t[4]) {
void f() { int f(int a) { ... } for(int i=0;i<4;i++)
n=10; // OK int g() { ... } t[i]=0;
int i=m; // OK ... }
... int i=f(2),j=g(); — void init(int t[],
— Conversion : — Références : int n) {
int i=int(x),j; void swap(int& a, for(int i=0;i<n;i++)
float x=float(i)/j; int& b){ t[i]=0;
— Pile/Tas int tmp=a; }
118
8. Allocation dynamique 8.6. Fiche de référence

Taille variable : — Combinaisons : && || — #include <string>
int* t=new int[n]; — if (i==0) j=1; using namespace std;
... string s="hop";
— if (i==0) j=1;
delete[] t; char c=s[0];
else j=2;
En paramètre (suite) : int l=s.size();
— void f(int* t,int n){ — if (i==0) { — #include <ctime>

t[i]=... j=1; s=double(clock())
} k=2; /CLOCKS_PER_SEC;
— void alloue(int*& t){ } — #include <cmath>
t=new int[n]; — bool t=(i==0); double pi=M_PI;
} if (t)
j=1; Erreurs fréquentes
2D :
int A[2][3]; — switch (i) { — Pas de définition de fonction
A[i][j]=...; case 1: dans une fonction !
int A[2][3]= ...;
{{1,2,3},{4,5,6}}; ...;
void f(int A[2][2]); break; — if (i=2) // NON!
case 2: if i==2 // NON!
2D dans 1D : if (i==2) then // NON!
case 3:
int A[2*3];
...; — for(int i=0,i<100,i++)
A[i+2*j]=...;
break; // NON!
Taille variable (suite) : default:
int *t,*s,n; ...; — int f() {...}
} int i=f; // NON!
Structures
— struct Point { — double x=1/3; // NON!
Entrées/Sorties
double x,y; int i,j;
— #include <iostream> x=i/j; // NON!
Color c; using namespace std;
}; x=double(i/j); //NON!
...
... cout <<"I="<<i<<endl; — double x[10],y[10];
Point a; cin >> i >> j; for(int i=1;i<=10;i++)
a.x=2.3; a.y=3.4; y[i]=2*x[i];//NON
a.c=Red; Divers
— int n=5;
Point b={1,2.5,Blue}; — i++; int t[n]; // NON
i--;
Compilation séparée — int f()[4] { // NON!
i-=2;
— #include "vect.h", aussi j+=3; int t[4];
dans vect.cpp ...
— j=i%n; // Modulo
— Fonctions : déclarations dans return t; // NON!
— #include <cstdlib> }
le .h, définitions dans le
... int t[4]; t=f();
.cpp
i=rand()%n;
— Types : définitions dans le .h x=rand()/ — int s[3]={1,2,3},t[3];
— Ne déclarer dans le .h que les double(RAND_MAX); t=s; // NON!
fonctions utiles. — #include <ctime> — int t[2];
— #pragma once au début du // Un seul appel t={1,2}; // NON!
fichier. srand((unsigned int) — struct Point {
— Ne pas trop découper. . . time(0)); double x,y;
— #include <cmath> } // NON!
Tests
double sqrt(double x);
— Comparaison : — Point a;
== != < > <= >= a={1,2}; // NON!
— Négation : ! double acos(double x); — #include "tp.cpp"//NON
119
8.6. Fiche de référence 8. Allocation dynamique

int f(int t[][]);//NON s=new int[n];// NON! — Faire des structures.
int t[2,3]; // NON! Imagine++ — Faire des fichiers séparés.
t[i,j]=...; // NON!
— Voir documentation. . . — Le .h doit suffire à l’utilisa-
int* t; teur (qui ne doit pas regarder
t[1]=...; // NON! Conseils
le .cpp)
— Nettoyer en quittant.
int* t=new int[2]; — Ne pas abuser du récursif.
int* s=new int[2];
s=t; // On perd s! — Indenter. — Ne pas oublier delete.
delete[] t; — Ne pas laisser de warning. — Compiler régulièrement.
delete[] s;//Déjà fait — Utiliser le debuggeur. — #include <cassert>
int *t,s;// s est int — Faire des fonctions. ...
// non int* — Tableaux : pas pour transcrire assert(x!=0);
t=new int[n]; une formule mathématique ! y=1/x;
120
9. Premiers objets
Chapitre 9
Premiers objets
Nous abordons maintenant notre dernière étape dans la direction d’une meilleure organisa-
tion des programmes. Tantôt nous structurions davantage les instructions (fonctions, fichiers),
tantôt nous nous intéressions aux données (structures, tableaux). Nous allons maintenant pen-
ser données et instructions simultanément : c’est là l’idée première des objets, même s’ils pos-
sèdent de nombreux autres aspects 1 . Enfin, nous justifierons l’emploi des objets par la notion
d’"interface" 2 .
9.1 Philosophie
Réunir les instructions en fonctions ou fichiers est une bonne chose. Réunir les don-
nées en tableaux ou structures aussi. Il arrive que les deux soient liées. C’est d’ailleurs
ce que nous avons constaté naturellement dans les exemples des chapitres précédents,
dans lesquels un fichier regroupait souvent une structure et un certain nombre de fonc-
tions s’y rapportant. C’est dans ce cas qu’il faut faire des objets.
L’idée est simple : un objet est un type de donnée possédant un certain nombre de
fonctionnalités propres 3 . Ainsi :
Ce ne sont plus les fonctions qui travaillent sur des données. Ce sont les
données qui possèdent des fonctionnalités.
Ces "fonctionnalités" sont souvent appelées les méthodes de l’objet. En pratique, l’uti-
lisation d’un objet remplacera ce genre d’instructions :
obj a ;
int i=f ( a ) ; // fonction f () appliquée à a
par :
1. Le plus important étant l’héritage, que nous ne verrons pas dans ce cours, préférant nous consacrer
à d’autres aspects du C++ plus indispensables et négligés jusqu’ici. . .
2. Nous exposerons une façon simple de créer des interfaces. Un programmeur C++ expérimenté
utilisera plutôt de l’héritage et des fonctions virtuelles pures, ce qui dépasse largement ce cours !
3. Il arrive même parfois qu’un objet regroupe des fonctionnalités sans pour autant stocker la
moindre donnée. Nous n’utiliserons pas ici cette façon de présenter les choses, dont le débutant pourrait
rapidement abuser.
9.2. Exemple simple 9. Premiers objets
obj a ;
i n t i =a . f ( ) ; / / a p p e l à l a méthode f ( ) de a
Vous l’avez compris, il s’agit ni plus ni moins de "ranger" les fonctions dans les
objets. Attention, crions tout de suite haut et fort qu’
il ne faut pas abuser des objets, surtout lorsqu’on est débutant. Les dangers
sont en effet :
— de voir des objets là où il n’y en n’a pas. Instructions et données ne
sont pas toujours liées.
— de mal penser l’organisation des données ou des instructions en ob-
jets.
Un conseil donc : quand ça devient trop compliqué pour vous, abandonnez
les objets.
Ce qui ne veut pas dire qu’un débutant ne doit pas faire d’objets. Des petits objets
dans des cas simples sont toujours une bonne idée. Mais seule l’expérience permet
de correctement organiser son programme, avec les bons objets, les bonnes fonctions,
etc. Un exemple simple : lorsqu’une fonction travaille sur deux types de données, le
débutant voudra souvent s’acharner à en faire malgré tout une méthode de l’un des
deux objets, et transformer :
obj1 a ;
obj2 b ;
int i=f (a , b ) ; // f () appliquée à a et b
en :
obj1 a ;
obj2 b ;
i n t i =a . f ( b ) ; / / méthode f ( ) de a a p p l i q u é e à b
/ / Est−c e b i e n l a c h o s e à f a i r e ????
Seuls un peu de recul et d’expérience permettent de rester simple quand il le faut. Le
premier code était le plus logique : la fonction f () n’a souvent rien à faire chez a, ni
chez b.
9.2 Exemple simple

On l’aura compris dans les exemples précédents, les méthodes des objets sont consi-
dérées comme faisant partie du type de l’objet, au même titre que ses champs. D’ailleurs,
les champs d’un objet sont parfois appelés membres de l’objet, et ses méthodes des fonc-
tions membres. Voici ce que cela donne en C++ :
s t r u c t obj {
int x ; / / champ x
int f ( ) ; / / méthode f ( )
int g( int y ) ; / / méthode g ( )
};
...
122
9. Premiers objets 9.2. Exemple simple
i n t main ( ) {
obj a ;
a . x =3;
i n t i =a . f ( ) ;
i n t j =a . g ( 2 ) ;
...
Il y a juste un détail, mais d’importance : la définition de la structure obj ci-dessus ne
fait que déclarer les méthodes. Elles ne sont définies nulle part dans le code précédent.
Pour les définir, on fait comme pour les fonctions habituelles, sauf que
pour permettre à plusieurs objets d’avoir les mêmes noms de méthodes, on

préfixe leur définition par le nom de l’objet suivi de :: a .
a. Ce mécanisme existe aussi pour les fonctions usuelles. Ce sont les espaces de nom, que
nous avons rencontrés et contournés immédiatement avec using namespace std pour ne
pas avoir à écrire std::cout ...
Voici comment cela s’écrit :

s t r u c t obj1 {
int x ; / / champ x
int f ( ) ; / / méthode f ( ) ( d é c l a r a t i o n )
int g( int y ) ; / / méthode g ( ) ( d é c l a r a t i o n )
};
s t r u c t obj2 {
double x ; / / champ x
double f ( ) ; / / méthode f ( ) ( d é c l a r a t i o n )
};
...
i n t obj1 : : f ( ) { / / méthode f ( ) de o b j 1 ( d é f i n i t i o n )
...
return . . .
}
i n t obj1 : : g ( i n t y ) { / / méthode g ( ) de o b j 1 ( d é f i n i t i o n )
...
return . . .
}
double o b j 2 : : f ( ) { / / méthode f ( ) de o b j 2 ( d é f i n i t i o n )
...
return . . .
}
...
i n t main ( ) {
obj1 a ;
obj2 b ;
a . x =3; / / l e champ x d e a e s t i n t
b . x = 3 . 5 ; / / c e l u i de b e s t d o u b l e
i n t i =a . f ( ) ; / / m é t h o d e f ( ) d e a ( donc o b j 1 : : f ( ) )
i n t j =a . g ( 2 ) ; / / m é t h o d e g ( ) d e a ( donc o b j 1 : : g ( ) )
double y=b . f ( ) ; / / m é t h o d e f ( ) d e b ( donc o b j 2 : : f ( ) )
123
9.3. Visibilité 9. Premiers objets
...
9.3 Visibilité
Il y a une règle que nous n’avons pas vue sur les espaces de nom mais que nous
pouvons facilement comprendre : quand on est "dans" un espace de nom, on peut
utiliser toutes les variables et fonctions de cet espace sans préciser l’espace en question.
Ainsi, ceux qui ont programmé cout et endl ont défini l’espace std puis se sont "placés
à l’intérieur" de cet espace pour programmer sans avoir à mettre std:: partout devant
cout, cin, endl et les autres. . . C’est suivant cette même logique, que
dans ses méthodes, un objet accède directement à ses champs et à ses autres
méthodes, c’est-à-dire sans rien mettre devant a !
a. Vous verrez peut-être parfois traîner le mot clé this qui est utile parfois en C++ et que
les programmeurs venant de Java mettent partout, en se trompant d’ailleurs sur son type.
Vous ne devriez pas en avoir besoin.
Par exemple, la fonction obj1::f() ci-dessus pourrait s’écrire :

1 i n t obj1 : : f ( ) { / / méthode f ( ) de o b j 1 ( d é f i n i t i o n )
2 i n t i =g ( 3 ) ; // méthode g ( ) de l ’ o b j e t dont l a méthode f ( ) e s t
3 // en t r a i n d e s ’ e x é c u t e r
4 i n t j =x+ i ; // champ x d e l ’ o b j e t d o n t l a m é t h o d e f ( ) e s t
5 // en t r a i n d e s ’ e x é c u t e r
6 return j ;
7 }
8 ...
9 i n t main ( ) {
10 o b j 1 a1 , a2 ;
11 i n t i 1 =a1 . f (); // C e t a p p e l va u t i l i s e r a1 . g ( ) l i g n e 2
12 // e t a1 . x l i g n e 4
13 i n t i 2 =a2 . f (); // C e t a p p e l va u t i l i s e r l i g n e 2 a2 . g ( )
14 // e t a2 . x l i g n e 4
Il est d’ailleurs normal qu’un objet accède simplement à ses champs depuis ses mé-
thodes, car
si un objet n’utilise pas ses champs dans une méthode, c’est probablement
qu’on est en train de ranger dans cet objet une fonction qui n’a rien à voir
avec lui (cf abus mentionné plus haut)
9.4 Exemple des matrices

En programmation, un exemple de source vaut mieux qu’un long discours. Si jus-
qu’ici vous naviguiez dans le vague, les choses devraient maintenant s’éclaircir ! Voilà
donc ce que devient notre exemple du chapitre 8 avec des objets :
124
9. Premiers objets 9.4. Exemple des matrices
# include <string >
/ / ==================================================
/ / f o n c t i o n s sur l e s m a t r i c e s
/ / p o u r r a i e n t e t r e d a n s un m a t r i c e . h e t m a t r i c e . cpp
/ / ========= d e c l a r a t i o n s ( d a n s l e . h )
s t r u c t Matrice {
i n t m, n ;
double ∗ t ;
void c r e e ( i n t m1, i n t n1 ) ;
void d e t r u i t ( ) ;
double g e t ( i n t i , i n t j ) ;
void s e t ( i n t i , i n t j , double x ) ;
void a f f i c h e ( s t r i n g s ) ;
};
M a t r i c e o p e r a t o r ∗ ( M a t r i c e A, M a t r i c e B ) ;
/ / ========= d é f i n i t i o n s ( d a n s l e . cpp )
void M a t r i c e : : c r e e ( i n t m1, i n t n1 ) {
/ / N o t e z que l e s p a r a m e t r e s ne s ’ a p p e l l e n t p l u s m e t n
/ / p o u r ne p a s m é l a n g e r a v e c l e s champs !
m=m1 ;
n=n1 ;
t =new double [m∗n ] ;
}
void M a t r i c e : : d e t r u i t ( ) {
delete [ ] t ;
}
double M a t r i c e : : g e t ( i n t i , i n t j ) {
r e t u r n t [ i +m∗ j ] ;
}
void M a t r i c e : : s e t ( i n t i , i n t j , double x ) {
t [ i +m∗ j ]= x ;
}
void M a t r i c e : : a f f i c h e ( s t r i n g s ) {
cout << s << " = " << endl ;
f o r ( i n t i = 0 ; i <m; i ++) {
f o r ( i n t j = 0 ; j <n ; j ++)
cout << g e t ( i , j ) << " " ;
cout << endl ;
}
125
9.4. Exemple des matrices 9. Premiers objets
M a t r i c e o p e r a t o r ∗ ( M a t r i c e A, M a t r i c e B ) {
i f (A. n ! =B .m) {
cout << " E r r e u r ! " << endl ;
exit (1);
}
Matrice C;
C . c r e e (A.m, B . n ) ;
f o r ( i n t i = 0 ; i <A.m; i ++)
f o r ( i n t j = 0 ; j <B . n ; j ++) {
/ / C i j =Ai0 ∗ B 0 j+Ai1 ∗ B 1 j + . . .
C. set ( i , j , 0 ) ;
f o r ( i n t k = 0 ; k<A. n ; k++)
C. set ( i , j ,
C . g e t ( i , j )+A. g e t ( i , k ) ∗ B . g e t ( k , j ) ) ;
}
return C;
}
/ / ==================== main ===========

i n t main ( )
{
M a t r i c e A;
A. c r e e ( 2 , 3 ) ;
f o r ( i n t i = 0 ; i < 2 ; i ++)
f o r ( i n t j = 0 ; j < 3 ; j ++)
A. s e t ( i , j , i + j ) ;
A. a f f i c h e ( "A" ) ;
Matrice B ;
B . cree ( 3 , 5 ) ;
f o r ( i n t i = 0 ; i < 3 ; i ++)
f o r ( i n t j = 0 ; j < 5 ; j ++)
B. set ( i , j , i+j ) ;
B . a f f i c h e ( "B" ) ;
M a t r i c e C=A∗B ;
C . a f f i c h e ( "C" ) ;
C. detruit ( ) ;
B. detruit ( ) ;
A. d e t r u i t ( ) ;
return 0;
}
126
9. Premiers objets 9.5. Cas des opérateurs
9.5 Cas des opérateurs

Il est un peu dommage que l’opérateur ∗ ne soit pas dans l’objet Matrice. Pour y
remédier, on adopte la convention suivante :
Soit A un objet. S’il possède une méthode operatorop(objB B), alors

AopB appellera cette méthode pour tout B de type objB.
En clair, le programme :
s t r u c t objA {
...
};
s t r u c t objB {
...
};
i n t o p e r a t o r +( objA A, objB B ) {
...
}
...
i n t main ( ) {
objA A;
objB B ;
i n t i =A+B ; / / a p p e l l e o p e r a t o r +(A, B )
...
peut aussi s’écrire :
s t r u c t objA {
...
i n t o p e r a t o r +( objB B ) ;
};
s t r u c t objB {
...
};
i n t objA : : o p e r a t o r +( objB B ) {
...
}
...
i n t main ( ) {
objA A;
objB B ;
i n t i =A+B ; / / a p p e l l e m a i n t e n a n t A . o p e r a t o r +(B )
...
ce qui pour nos matrices donne :
...
Matrice operator ∗( Matrice B ) ;
};
...
127
9.5. Cas des opérateurs 9. Premiers objets
/ / A∗B a p p e l l e A . o p e r a t o r ∗ ( B ) donc t o u s
/ / l e s champs e t f o n c t i o n s u t i l i s é s d i r e c t e m e n t
/ / c o n c e r n e n t ce qui é t a i t p r é f i x é précédemment par A.
Matrice Matrice : : operator ∗( Matrice B) {
/ / On e s t d a n s l ’ o b j e t A du A∗B a p p e l é
i f ( n ! =B .m) { / / Le n d e A
cout << " E r r e u r ! " << endl ;
exit (1);
}
Matrice C;
C . c r e e (m, B . n ) ;
f o r ( i n t i = 0 ; i <m; i ++)
f o r ( i n t j = 0 ; j <B . n ; j ++) {
/ / C i j =Ai0 ∗ B 0 j+Ai1 ∗ B 1 j + . . .
C. set ( i , j , 0 ) ;
f o r ( i n t k = 0 ; k<n ; k++)
/ / g e t ( i , j ) s e r a c e l u i de A
C. set ( i , j ,
C . g e t ( i , j )+ g e t ( i , k ) ∗ B . g e t ( k , j ) ) ;
}
return C;
}
Notez aussi que l’argument de l’opérateur n’a en fait pas besoin d’être un objet.
Ainsi pour écrire le produit B=A∗2, il suffira de créer la méthode :
M a t r i c e M a t r i c e : : o p e r a t o r ∗ ( double lambda ) {
...
}
...
B=A∗ 2 ; / / A p p e l l e A . o p e r a t o r ∗ ( 2 )
Par contre, pour écrire B=2∗A, on ne pourra pas créer :
M a t r i c e double : : o p e r a t o r ∗ ( M a t r i c e A) / / IMPOSSIBLE c a r d o u b l e
/ / n ’ e s t p a s un o b j e t !
car cela reviendrait à définir une méthode pour le type double, qui n’est pas un ob-
jet 4 . Il faudra simplement se contenter d’un opérateur standard, qui, d’ailleurs, sera
bien inspiré d’appeler la méthode Matrice::operator∗(double lambda) si elle est déjà
programmée :
M a t r i c e o p e r a t o r ∗ ( double lambda , M a t r i c e A) {
r e t u r n A∗lambda ; / / d é f i n i précé demm ent , r i e n à r e p r o g r a m m e r !
}
...
B=2∗A; / / a p p e l l e o p e r a t o r ∗ ( 2 ,A) q u i a p p e l l e à s o n t o u r
/ / A. o p e r a t o r ∗(2)
Nous verrons au chapitre suivant d’autres opérateurs utiles dans le cas des objets. . .
4. et de toute façon n’appartient pas au programmeur !
128
9. Premiers objets 9.6. Interface
9.6 Interface
Si on regarde bien le main() de notre exemple de matrice, on s’aperçoit qu’il n’utilise

plus les champs des Matrice mais seulement leurs méthodes. En fait, seule la partie
};
intéresse l’utilisateur. Que les dimensions soient dans des champs int m et int n et que
les éléments soient dans un champ double∗ t ne le concerne plus : c’est le problème de
celui qui programme les matrices. Si ce dernier trouve un autre moyen 5 de stocker un
tableau bidimensionnel de double, libre à lui de le faire. En fait
Si l’utilisateur des Matrice se conforme aux déclarations des méthodes

ci-dessus, leur concepteur peut les programmer comme il l’entend. Il peut
même les reprogrammer ensuite d’une autre façon : les programmes de l’uti-
lisateur marcheront toujours ! C’est le concept même d’une interface :
— Le concepteur et l’utilisateur des objets se mettent d’accord sur les mé-
thodes qui doivent exister.
— Le concepteur les programme : il implémente a l’interface.
— L’utilisateur les utilise de son côté.
— Le concepteur peut y retoucher sans gêner l’utilisateur.
En particulier le fichier d’en-tête de l’objet est le seul qui intéresse l’utilisa-
teur. C’est lui qui précise l’interface, sans rentrer dans les détails d’implé-
mentation. Bref, reliées uniquement par l’interface, utilisation et implémen-
tation deviennent indépendantes b .
a. Il se trouve en général face au difficile problème du choix de l’implémentation : certaines
façons de stocker les données peuvent rendre efficaces certaines méthodes au détriment de
certaines autres, ou bien consommer plus ou moins de mémoire, etc. Bref, c’est lui qui doit
gérer les problèmes d’algorithmique. C’est aussi en général ce qui fait que, pour une même
interface, un utilisateur préférera telle ou telle implémentation : le concepteur devra aussi
faire face à la concurrence !
b. Ce qui est sûr, c’est que les deux y gagnent : le concepteur peut améliorer son implémen-
tation sans gêner l’utilisateur, l’utilisateur peut changer pour une implémentation concurrente
sans avoir à retoucher son programme.
5. Et il en existe ! Par exemple pour stocker efficacement des matrices creuses, c’est-à-dire celles dont
la plupart des éléments sont nuls. Ou bien, en utilisant des objets implémentant déjà des tableaux de fa-
çon sûre et efficace, comme il en existe déjà en C++ standard ou dans des bibliothèques complémentaires
disponibles sur le WEB. Etc, etc.
129
9.7. Protection 9. Premiers objets
9.7 Protection
9.7.1 Principe
Tout cela est bien beau, mais les détails d’implémentation ne sont pas entièrement
cachés : la définition de la structure dans le fichier d’en-tête fait apparaître les champs
utilisés pour l’implémentation. Du coup, l’utilisateur peut être tenté de les utiliser !
Rien ne l’empêche en effet de faire des bêtises :
M a t r i c e A;
A. c r e e ( 3 , 2 ) ;
A.m= 4 ; / / A i e ! L e s a c c è s v o n t ê t r e f a u x !
ou tout simplement de préférer ne pas s’embêter en remplaçant
f o r ( i n t i = 0 ; i < 3 ; i ++)
f o r ( i n t j = 0 ; j < 2 ; j ++)
A. s e t ( i , j , 0 ) ;
par
f o r ( i n t i = 0 ; i < 6 ; i ++)
A. t [ i ] = 0 ; / / H o r r e u r ! Et s i on i m p l é m e n t e a u t r e m e n t ?
Dans ce cas, l’utilisation n’est plus indépendante de l’implémentation et on a perdu
une grande partie de l’intérêt de la programmation objet. . . C’est ici qu’intervient la
possibilité d’empêcher l’utilisateur d’accéder à certains champs ou même à certaines
méthodes. Pour cela :
1. Remplacer struct par class : tous les champs et les méthodes de-
viennent privés : seules les méthodes de l’objet lui-même ou de tout
autre objet du même type a peuvent les utiliser.
2. Placer la déclaration public: dans la définition de l’objet pour débu-
ter la zone b à partir de laquelle seront déclarés les champs et méthodes
publics, c’est-à-dire accessibles à tous.
a. Bref, les méthodes de la classe en question !
b. On pourrait à nouveau déclarer des passages privés avec private:, puis publics, etc. Il
existe aussi des passages protégés, notion qui dépasse ce cours. . .
Voici un exemple :
c l a s s obj {
int x , y ;
void a_moi ( ) ;
public :
int z ;
void pour_tous ( ) ;
void une_autre ( o b j A ) ;
};
void o b j : : a_moi ( ) {
x=..; / / OK
..=y; / / OK
130
9. Premiers objets 9.7. Protection
z=..; / / OK
}
void o b j : : pour_tous ( ) {
x=..; / / OK
a_moi ( ) ; / / OK
}
void o b j : : une_autre ( o b j A) {
x=A. x ; / / OK
A. a_moi ( ) ; / / OK
}
...
i n t main ( ) {
o b j A, B ;
A. x = . . ; / / NON!
A. z = . . ; / / OK
A. a_moi ( ) ; / / NON!
A. pour_tous ( ) ; / / OK
A. une_autre ( B ) ; / / OK
Dans le cas de nos matrices, que nous avions déjà bien programmées, il suffit de les
définir comme suit :
c l a s s Matrice {
i n t m, n ;
double ∗ t ;
public :
};
pour empêcher une utilisation dépendante de l’implémentation.
9.7.2 Structures vs Classes

Notez que, finalement, une structure est une classe où tout est public. . . Les anciens
programmeurs C pensent souvent à tort que les structures du C++ sont les mêmes
qu’en C, c’est-à-dire qu’elles ne sont pas des objets et qu’elles n’ont pas de méthode 6 .
9.7.3 Accesseurs
Les méthodes get () et set () qui permettent d’accéder en lecture (get) ou en écriture
(set) à notre classe, sont appelées accesseurs. Maintenant que nos champs sont tous pri-
vés, l’utilisateur n’a plus la possibilité de retrouver les dimensions d’une matrice. On
rajoutera donc deux accesseurs en lecture vers ces dimensions :
6. sans compter qu’ils les déclarent souvent comme en C avec d’inutiles typedef. Mais bon, ceci ne
devrait pas vous concerner !
131
9.8. TP 9. Premiers objets
i n t M a t r i c e : : nbLin ( ) {
r e t u r n m;
}
i n t M a t r i c e : : nbCol ( ) {
return n ;
}
i n t main ( ) {
...
f o r ( i n t i = 0 ; i <A. nbLin ( ) ; i ++)
f o r ( i n t j = 0 ; j <A. nbCol ( ) ; j ++)
A. s e t ( i , j , 0 ) ;
mais pas en écriture, ce qui est cohérent avec le fait que changer m en cours de route
rendrait fausses les fonctions utilisant t [ i+m∗j] !
F IGURE 9.1 – Fractales
9.8 TP
Vous devriez maintenant pouvoir faire le TP en A.8 qui dessine quelques courbes
fractales (figure 9.1) en illustrant le concept d’objet..
132
9. Premiers objets 9.9. Fiche de référence

Boucles — Portée : — Retour :
— do { int i; int signe(double x) {
... // i=j; interdit! if (x<0)
} while(!ok); int j=2; return -1;
i=j; // OK! if (x>0)
— int i=1; if (j>1) { return 1;
while(i<=100) { int k=3; return 0;
... j=k; // OK! }
i=i+1; } void afficher(int x,
} //i=k; interdit! int y) {
— for(int i=1;i<=10;i++) — Types : if (x<0 || y<0)
... int i=3; return;
— for(int i=1,j=10;j>i; double x=12.3; if (x>=w || y>=h)
i=i+2,j=j-3) char c=’A’; return;
... string s="hop"; DrawPoint(x,y,RED);
bool t=true; }
— for (int i=...)
for (int j=...) { float y=1.2f; — Appel :
//saute cas i==j unsigned int j=4; int f(int a) { ... }
if (i==j) signed char d=-128; int g() { ... }
continue; unsigned char d=25; ...
... complex<double> int i=f(2),j=g();
} z(2,3);
— Références :
void swap(int& a,
Clavier — Variables globales :
int& b){
— Debug : F5 int n;
int tmp=a;
const int m=12;
— Step over : F10 a=b;b=tmp;
void f() {
}
— Step inside : F11 n=10; // OK
...
int i=m; // OK
— Indent : Ctrl+A,Ctrl+I int x=3,y=2;
...
— Step out : Maj+F11 swap(x,y);
— Conversion :
— Gest. tâches : Ctrl+Maj+Ech int i=int(x),j; — Surcharge :
float x=float(i)/j; int hasard(int n);
Variables — Pile/Tas int hasard(int a,
— Définition : int b);
int i; Fonctions double hasard();
int k,l,m; — Définition : — Opérateurs :
int plus(int a,int b){ vect operator+(
— Affectation :
int c=a+b; vect A,vect B) {
i=2;
return c; ...
j=i;
} }
k=l=3;
void affiche(int a) { ...
— Initialisation : cout << a << endl; vect C=A+B;
int n=5,o=n; }
— Constantes : — Déclaration : — Pile des appels
const int s=12; int plus(int a,int b); — Itératif/Récursif
133
9.9. Fiche de référence 9. Premiers objets

Tableaux — 2D dans 1D : void obj::a_moi() {
— Définition : int A[2*3]; x=..; // OK
A[i+2*j]=...; ..=y; // OK
— double x[5],y[5];
z=..; // OK
for(int i=0;i<5;i++) — Taille variable (suite) :
int *t,*s,n; }
y[i]=2*x[i];
void obj::pour_tous(){
— const int n=5; Structures x=..; // OK
int i[n],j[2*n]; — struct Point { a_moi(); // OK
— Initialisation : double x,y; }
int t[4]={1,2,3,4}; Color c; void autre(obj A) {
string s[2]={"ab","c"}; }; x=A.x; // OK
— Affectation : ... A.a_moi(); // OK
int s[3]={1,2,3},t[3]; Point a; }
for (int i=0;i<3;i++) a.x=2.3; a.y=3.4; ...
t[i]=s[i]; a.c=Red; int main() {
Point b={1,2.5,Blue}; obj A,B;
— En paramètre : A.x=..; //NON
— Une structure est un objet en-
— void init(int t[4]) { tièrement public (→ cf ob- A.z=..; //OK
for(int i=0;i<4;i++) jets !) A.a_moi(); //NON
t[i]=0; A.pour_tous(); //OK
} Objets A.autre(B); //OK
— void init(int t[], — struct obj { — class obj {
int n) { int x; // champ obj operator+(obj B);
for(int i=0;i<n;i++) int f(); // méthode };
t[i]=0; int g(int y); ...
} }; int main() {
— Taille variable : int obj::f() { obj A,B,C;
int* t=new int[n]; int i=g(3); // mon g C=A+B;
... int j=x+i; // mon x // C=A.operator+(B)
delete[] t; return j;
} Compilation séparée
— En paramètre (suite) :
... — #include "vect.h", aussi
— void f(int* t,int n){ int main() { dans vect.cpp
t[i]=... obj a;
} a.x=3; — Fonctions : déclarations dans
— void alloue(int*& t){ int i=a.f(); le .h, définitions dans le
t=new int[n]; .cpp
— class obj {
} int x,y; — Types : définitions dans le .h
— 2D : void a_moi(); — Ne déclarer dans le .h que les
int A[2][3]; public: fonctions utiles.
A[i][j]=...; int z;
int A[2][3]= void pour_tous(); — #pragma once au début du
{{1,2,3},{4,5,6}}; void autre(obj A); fichier.
void f(int A[2][2]); }; — Ne pas trop découper. . .
134
9. Premiers objets 9.9. Fiche de référence

Tests — double x[10],y[10]; — #include <cmath>
— Comparaison : for(int i=1;i<=10;i++) double sqrt(double x);
== != < > <= >= y[i]=2*x[i];//NON double cos(double x);
— int n=5; double sin(double x);
— Négation : !
int t[n]; // NON double acos(double x);
— Combinaisons : && ||
— int f()[4] { // NON! — #include <string>
— if (i==0) j=1;
int t[4]; using namespace std;
— if (i==0) j=1; ... string s="hop";
else j=2; return t; // NON! char c=s[0];
} int l=s.size();
— if (i==0) { int t[4]; t=f();
j=1; — int s[3]={1,2,3},t[3]; s=double(clock())
k=2; t=s; // NON! /CLOCKS_PER_SEC;
}
— int t[2];
— bool t=(i==0); — #include <cmath>
t={1,2}; // NON!
if (t) double pi=M_PI;
— struct Point {
j=1; double x,y; Imagine++
— switch (i) { } // NON!
case 1: — Voir documentation. . .
— Point a;
...; a={1,2}; // NON! Conseils
...;
break; — #include "tp.cpp"//NON — Nettoyer en quittant.
case 2: — int f(int t[][]);//NON
case 3: int t[2,3]; // NON!
...; t[i,j]=...; // NON! — Indenter.
break; — int* t; — Ne pas laisser de warning.
default: t[1]=...; // NON!
...; — Utiliser le debuggeur.
— int* t=new int[2];
} int* s=new int[2]; — Faire des fonctions.
Entrées/Sorties s=t; // On perd s! — Tableaux : pas pour transcrire
delete[] t; une formule mathématique !
— #include <iostream> delete[] s;//Déjà fait
using namespace std; — Faire des structures.
... — int *t,s;// s est int
// non int* — Faire des fichiers séparés.
cout <<"I="<<i<<endl;
cin >> i >> j; t=new int[n]; — Le .h doit suffire à l’utilisa-
s=new int[n];// NON! teur (qui ne doit pas regarder
Erreurs fréquentes le .cpp)
Divers
— Pas de définition de fonction
— i++; — Ne pas abuser du récursif.
dans une fonction !
i--;
— int q=r=4; // NON! — Ne pas oublier delete.
i-=2;
— if (i=2) // NON! j+=3; — Compiler régulièrement.
if i==2 // NON! — j=i%n; // Modulo — #include <cassert>
if (i==2) then // NON! ...
— #include <cstdlib>
— for(int i=0,i<100,i++) ... assert(x!=0);
// NON! i=rand()%n; y=1/x;
— int f() {...} x=rand()/ — Faire des objets.
int i=f; // NON! double(RAND_MAX);
— Ne pas toujours faire des ob-
— double x=1/3; // NON! — #include <ctime>
jets !
int i,j; // Un seul appel
x=i/j; // NON! srand((unsigned int) — Penser interface / implémen-
x=double(i/j); //NON! time(0)); tation / utilisation.
135
10. Constructeurs et Destructeurs
Chapitre 10
Constructeurs et Destructeurs
Dans ce long chapitre, nous allons voir comment le C++ offre la possibilité d’intervenir
sur ce qui se passe à la naissance et à la mort d’un objet. Ce mécanisme essentiel repose sur la
notion de constructeur et de destructeur. Ces notions sont très utiles, même pour le débutant
qui devra au moins connaître leur forme la plus simple. Nous poursuivrons par un aspect bien
pratique du C++, tant pour l’efficacité des programmes que pour la découverte de bugs à la
compilation : une autre utilisation du const. Enfin, pour les plus avancés, nous expliquerons
aussi comment les problèmes de gestion du tas peuvent être ainsi automatisés.
10.1 Le problème
Avec l’apparition des objets, nous avons transformé :
s t r u c t point {
int x , y ;
};
...
point a ;
a . x =2; a . y=3;
i =a . x ; j =a . y ;
en :
c l a s s point {
int x , y ;
public :
void g e t ( i n t&X , i n t&Y ) ;
void s e t ( i n t X , i n t Y ) ;
};
...
point a ;
a . set (2 ,3);
a . get ( i , j ) ;
Conséquence :
point a = { 2 , 3 } ;
10.2. La solution 10. Constructeurs et Destructeurs
est maintenant impossible. On ne peut remplir les champs privés d’un objet, même à
l’initialisation, car cela permettrait d’accéder en écriture à une partie privée 1 !
10.2 La solution
La solution est la notion de constructeur :
c l a s s point {
int x , y ;
public :
point ( i n t X, i n t Y ) ;
};
p o i n t : : p o i n t ( i n t X , i n t Y) {
x=X ;
y=Y ;
}
...
point a ( 2 , 3 ) ;
Un constructeur est une méthode dont le nom est le nom de la classe elle-
même. Il ne retourne rien mais son type de retour n’est pas void : il n’a pas
de type de retour. Le constructeur est appelé à la création de l’objet et ses
paramètres sont passés avec la syntaxe ci-dessus. Il est impossible d’appeler
un constructeur sur un objet déjà créé.
Ici, c’est le constructeur point :: point(int X,int Y) qui est défini. Notez bien qu’il
est impossible d’appeler un constructeur sur un objet déjà contruit :
p o i n t a ( 1 , 2 ) ; / / OK! V a l e u r s i n i t i a l e s
/ / On ne f a i t p a s comme ç a p o u r c h a n g e r l e s champs d e a .
a . p o i n t ( 3 , 4 ) ; / / ERREUR!
/ / Mais p l u t ô t comme ç a .
a . set (3 ,4); / / OK!
10.3 Cas général

10.3.1 Constructeur vide
Lorsqu’un objet est créé sans rien préciser, c’est le construteur vide qui est appelé,
c’est-à-dire celui sans paramètre. Ainsi, le programme :
c l a s s obj {
public :
obj ( ) ;
};
1. En réalité, il y a une autre raison, plus profonde et trop difficile à expliquer ici, qui fait qu’en
général, dès qu’on programme des objets, cette façon d’initialiser devient impossible.
138
10. Constructeurs et Destructeurs 10.3. Cas général
obj : : obj ( ) {
cout << " h e l l o " << endl ;
}
...
obj a ; / / a p p e l l e l e c o n s t r u c t e u r par d é f a u t
affiche "hello".
Le constructeur vide obj::obj() est appelé à chaque fois qu’on construit

un objet sans préciser de paramètre. Font exception les paramètres des fonc-
tions et leur valeur de retour qui, eux, sont construits comme des recopies
des objets passés en paramètre ou retournés a .
a. Nous allons voir plus loin cette construction par copie.
c l a s s obj {
public :
obj ( ) ;
};
obj : : obj ( ) {
cout << " o b j " ;
}
void f ( o b j d ) {
}
obj g ( ) {
obj e ;
cout << 6 << " " ;
return e ;
}
i n t main ( )
{
cout << 0 << " " ;
obj a ;
cout << 1 << " " ;
f o r ( i n t i = 2 ; i <=4; i ++) {
obj b ;
cout << i << " " ;
}
f (a );
cout << 5 << " " ;
a=g ( ) ;
139
10.3. Cas général 10. Constructeurs et Destructeurs
return 0;
}
affiche :
0 obj 1 obj 2 obj 3 obj 4 5 obj 6
Bien repérer les deux objets non construits avec obj :: obj () : le paramètre d de f () , copie
de a, et la valeur de retour de g(), copie de e.
10.3.2 Plusieurs constructeurs

Un objet peut avoir plusieurs constructeurs.
c l a s s point {
int x , y ;
public :
point ( i n t V ) ;
};
x=X ;
y=Y ;
}
p o i n t : : p o i n t ( i n t V) {
x=y=V ;
}
...
p o i n t a ( 2 , 3 ) ; / / c o n s t r u i t a v e c p o i n t (X, Y)
point b ( 4 ) ; / / c o n s t r u i t a v e c p o i n t (V)
Il faut cependant retenir la chose suivante :
Si on ne définit aucun constructeur, tout se passe comme s’il n’y avait qu’un
constructeur vide ne faisant rien. Mais attention : dès qu’on définit soi-même
un constructeur, le constructeur vide n’existe plus, sauf si on le redéfinit soi-
même.
Par exemple, le programme :
c l a s s point {
int x , y ;
};
...
point a ;
a . set (2 ,3);
point b ; / / OK
devient, avec un constructeur, un programme qui ne se compile plus :
c l a s s point {
int x , y ;
public :
140
10. Constructeurs et Destructeurs 10.3. Cas général
};
x=X ;
y=Y ;
}
...
point b ; / / ERREUR! p o i n t ( ) n ’ e x i s t e p l u s
et il faut alors rajouter un constructeur vide, même s’il ne fait rien :
c l a s s point {
int x , y ;
public :
point ( ) ;
};
point : : point ( ) {
}
x=X ;
y=Y ;
}
...
point b ; / / OK! c o n s t r u i t a v e c p o i n t ( )
10.3.3 Tableaux d’objets

Il n’est pas possible de spécifier globalement quel constructeur est appelé pour les
éléments d’un tableau. C’est toujours le constructeur vide qui est appelé. . .
point t [ 3 ] ; / / C o n s t r u i t 3 f o i s avec l e c o n s t r u c t e u r v i d e
/ / s u r c h a c u n d e s é l é m e n t s du t a b l e a u
p o i n t ∗ s=new p o i n t [ n ] ; / / Idem , n f o i s
p o i n t ∗ u=new p o i n t ( 1 , 2 ) [ n ] ; / / ERREUR e t HORREUR!
/ / Un e s s a i d e c o n s t r u i r e l e s u [ i ]
/ / avec point ( 1 , 2 ) , qui n ’ e x i s t e pas
Il faudra donc écrire :
p o i n t ∗ u=new p o i n t [ n ] ;
f o r ( i n t i = 0 ; i <n ; i ++)
u[ i ] . set ( 1 , 2 ) ;
ce qui n’est pas vraiment identique car on construit alors les points à vide puis on les
affecte.
Par contre, il est possible d’écrire :
point t [ 3 ] = { point ( 1 , 2 ) , point ( 2 , 3 ) , point ( 3 , 4 ) } ;
ce qui n’est évidemment pas faisable pour un tableau de taille variable.
141
10.4. Objets temporaires 10. Constructeurs et Destructeurs
10.4 Objets temporaires

On peut, en appelant soi-même un constructeur a , construire un objet sans
qu’il soit rangé dans une variable. En fait il s’agit d’un objet temporaire
sans nom de variable et qui meurt le plus tôt possible.
a. Attention, nous avions déjà dit qu’on ne pouvait pas appeler un constructeur d’un objet
déjà construit. Ici, c’est autre chose : on appelle un constructeur sans préciser d’objet !
void f ( p o i n t p ) {
...
}
point g ( ) {
point e ( 1 , 2 ) ; / / pour l e r e t o u r n e r
return e ;
}
...
point a ( 3 , 4 ) ; / / uniquement pour p o u v o i r a p p e l e r f ( )
f (a );
point b ;
b=g ( ) ;
point c ( 5 , 6 ) ; / / on p o u r r a i t a v o i r e n v i e d e f a i r e
b=c ; / / ça pour m e t t r e b à ( 5 , 6 )
peut largement s’alléger, en ne stockant pas dans des variables les points pour lesquels
ce n’était pas utile :
1 void f ( p o i n t p ) {
2 ...
3 }
4 point g ( ) {
5 return point ( 1 , 2 ) ; / / r e t o u r n e d i r e c t e m e n t
6 / / l ’ objet temporaire point (1 ,2)
7 }
8 ...
9 f ( p o i n t ( 3 , 4 ) ) ; / / P a s s e d i r e c t e m e n t l ’ o b j . temp . p o i n t ( 3 , 4 )
10 point b ;
11 b=g ( ) ;
12 b= p o i n t ( 5 , 6 ) ; / / a f f e c t e directement b à l ’ objet
13 / / temporaire point (5 ,6)
Attention à la ligne 12 : elle est utile quand b existe déjà mais bien comprendre qu’on
construit un point (5,6) temporaire qui est ensuite affecté à b. On ne remplit pas b
directement avec (5,6) comme on le ferait avec un b. set (5,6) .
Attention aussi à l’erreur suivante, très fréquente. Il ne faut pas écrire
p o i n t p= p o i n t ( 1 , 2 ) ; / / NON! ! ! ! ! ! !
mais plutôt
point p ( 1 , 2 ) ; / / OUI !
142
10. Constructeurs et Destructeurs 10.5. TP
L’utilité de ces objets temporaires est visible sur un exemple réel :

p o i n t p o i n t : : o p e r a t o r +( p o i n t b ) {
p o i n t c ( x+b . x , y+b . y ) ;
return c ;
}
...
point a ( 1 , 2 ) , b ( 2 , 3 ) ;
c=a+ f ( b ) ;
s’écrira plutôt :
p o i n t p o i n t : : o p e r a t o r +( p o i n t b ) {
r e t u r n p o i n t ( x+b . x , y+b . y ) ;
}
...
c= p o i n t ( 1 , 2 ) + f ( p o i n t ( 2 , 3 ) ) ;
F IGURE 10.1 – Jeu de Tron.
10.5 TP
Nous pouvons faire une pause et aller faire le TP que nous proposons en A.8. Il
s’agit de programmer le jeu de motos de Tron (figure 10.1).
10.6 Références Constantes

10.6.1 Principe
Lorsqu’on passe un objet en paramètre à une fonction, il est recopié. Cette recopie
est source d’inefficacité. Ainsi, dans le programme suivant :
c o n s t i n t N= 1 0 0 0 ;
c l a s s vecteur {
double t [N] ;
...
};
c l a s s matrice {
double t [N] [N] ;
143
10.6. Références Constantes 10. Constructeurs et Destructeurs
...
};
/ / r é s o u t AX=B
void s o l v e ( m a t r i c e A, v e c t e u r B , v e c t e u r& X) {
...
}
...
vecteur b , x ;
matrice a ;
...
s o l v e ( a , b , x ) ; / / r é s o u t ax=b
les variables A et B de la fonction solve() sont des copies des objets a et b de la fonction
appelante. Notez bien que, passé par référence, le paramètre X n’est pas une copie car
il s’agit juste d’un lien vers la variable x.
La recopie de a dans A n’est pas une très bonne chose. La variable a fait dans notre
cas pas moins de 8 millions d’octets : les recopier dans A prend du temps ! Même pour
des objets un peu moins volumineux, si une fonction est appelée souvent, cette recopie
peut ralentir le programme. Lorsqu’une fonction est courte, il n’est pas rare non plus
que ce temps de recopie soit supérieur à celui passé dans la fonction !
L’idée est alors, pour des objets volumineux, de les passer eux-aussi par référence,
même si la fonction n’a pas à les modifier ! Il suffit donc de définir la fonction solve()
ainsi :
void s o l v e ( m a t r i c e& A, v e c t e u r& B , v e c t e u r& X) {
...
pour accélérer le programme.
Cependant, cette solution n’est pas sans danger. Rien ne garantit en effet que solve
ne modifie pas ses paramètres A et B. Il est donc possible, suivant la façon dont solve
est programmée, qu’en sortie de solve(a,b,x), a et b eux-mêmes aient été modifiés,
alors que précédemment c’étaient leurs copies A et B qui l’étaient. C’est évidemment
gênant ! Le C++ offre heureusement la possibilité de demander au compilateur de vérifier
qu’une variable passée par référence n’est pas modifiée par la fonction. Il suffit de rajouter
const au bon endroit :
void s o l v e ( c o n s t m a t r i c e& A, c o n s t v e c t e u r& B , v e c t e u r& X) {
...
Si quelque part dans solve (ou dans les sous-fonctions appelées par solve !), la variable
A ou la variable B est modifiée, alors il y aura erreur de compilation. La règle est donc :
Lorsqu’un paramètre obj o d’une fonction est de taille importante a , c’est

une bonne idée de le remplacer par const obj& o.
a. En réalité, le programme s’en trouvera accéléré pour la plupart des objets courants.
10.6.2 Méthodes constantes

Considérons le programme suivant :
void g ( i n t& x ) {
144
10. Constructeurs et Destructeurs 10.6. Références Constantes
cout << x << endl ;

}
void f ( c o n s t i n t& y ) {
double z=y ; / / OK ne m o d i f i e p a s y
g(y ) ; / / OK?
}
...
i n t a =1;
f (a );
La fonction f () ne modifie pas son paramètre y et tout va bien. Imaginons une deuxième
version de g() :
void g ( i n t& x ) {
x ++;
}
Alors y serait modifiée dans f () à cause de l’appel à g(). Le programme ne se compi-
lerait évidemment pas. . . En réalité, la première version de g() serait refusée elle aussi
car
pour savoir si une sous-fonction modifie ou non un des paramètres d’une

fonction, le compilateur ne se base que sur la déclaration de cette sous-
fonction et non sur sa définition complète a .
a. Le C++ n’essaie pas de deviner lui-même si une fonction modifie ses paramètres
puisque la logique est que le programmeur indique lui-même avec const ce qu’il veut faire,
et que le compilateur vérifie que le programme est bien cohérent.
Bref, notre premier programme ne se compilerait pas non plus car l’appel g(y) avec
const int& y impose que g() soit déclarée void g(const int& x). Le bon programme est
donc :
void g ( c o n s t i n t& x ) {
cout << x << endl ;
}
void f ( c o n s t i n t& y ) {
double z=y ; / / OK ne m o d i f i e p a s y
g(y ) ; / / OK! Pas b e s o i n d ’ a l l e r r e g a r d e r d a n s g ( )
}
...
i n t a =1;
f (a );
Avec les objets, nous avons besoin d’une nouvelle notion. En effet, considérons
maintenant :
void f ( c o n s t o b j& o ) {
o . g ( ) ; / / OK?
}
Il faut indiquer au compilateur si la méthode g() modifie ou non l’objet o. Cela se fait
avec la syntaxe suivante :
145
10.7. Destructeur 10. Constructeurs et Destructeurs
c l a s s obj {
...
void g ( ) c o n s t ;
...
};
void o b j : : g ( ) c o n s t {
...
}
void f ( c o n s t o b j& o ) {
o . g ( ) ; / / OK! Méthode c o n s t a n t e
}
Cela n’est finalement pas compliqué :
On précise qu’une méthode est constante, c’est-à-dire qu’elle ne modifie pas
son objet, en plaçant const derrière les parenthèses de sa déclaration et de
sa définition.
On pourrait se demander si toutes ces complications sont bien nécessaires, notre
point de départ étant juste le passage rapide de paramètres en utilisant les références.
En réalité, placer des const dans les méthodes est une très bonne chose. Il ne faut pas
le vivre comme une corvée de plus, mais comme une façon de préciser sa pensée :
"suis-je ou non en train d’ajouter une méthode qui modifie l’objets ?". Le compilateur
va ensuite vérifier pour nous la cohérence de ce const avec tout le reste. Ceci a deux
effets importants :
— Découverte de bugs à la compilation. (On pensait qu’un objet n’était pas modifié
et il l’est.)
— Optimisation du programme 2 .
—
La fin du chapitre peut être considérée comme difficile. Il est toutefois recommandé de la com-
prendre, même si la maîtrise et la mise en application de ce qui s’y trouve est laissée aux plus
avancés.
—
10.7 Destructeur
Lorsqu’un objet meurt, une autre de ses méthodes est appelée : le destructeur.
Le destructeur :
— est appelé quand l’objet meurt.
— porte le nom de la classe précédé de ˜.
— comme les constructeurs, n’a pas de type.
— n’a pas de paramètres (Il n’y a donc qu’un seul destructeur par classe.)
2. Lorsque le compilateur sait qu’un objet reste constant pendant une partie du programme, il peut
éviter d’aller le relire à chaque fois. Le const est donc une information précieuse pour la partie optimi-
sation du compilateur.
146
10. Constructeurs et Destructeurs 10.7. Destructeur
Un exemple sera plus parlant. Rajoutons un destructeur au programme de la sec-

tion 10.3 :
c l a s s obj {
public :
obj ( ) ;
~obj ( ) ;
};
obj : : obj ( ) {
cout << " o b j " ;
}
obj : : ~ obj ( ) {
cout << " ~ " ;
}
void f ( o b j d ) {
}
obj g ( ) {
obj e ;
cout << 6 << " " ;
return e ;
}
i n t main ( )
{
cout << 0 << " " ;
obj a ;
cout << 1 << " " ;
f o r ( i n t i = 2 ; i <=4; i ++) {
obj b ;
cout << i << " " ;
}
f (a );
cout << 5 << " " ;
a=g ( ) ;
return 0;
}
Il affiche maintenant :
0 obj 1 obj 2 ~ obj 3 ~ obj 4 ~ ~ 5 obj 6 ~ ~ ~
Repérez bien à quel moment les objets sont détruits. Constatez aussi qu’il y a plus
d’appels au destructeur (7) qu’au constructeur (5) : nous n’avons pas encore parlé du
constructeur pour les objets qui sont construits par copie. . .
147
10.8. Destructeurs et tableaux 10. Constructeurs et Destructeurs
10.8 Destructeurs et tableaux

Le destructeur est appelé pour tous les éléments du tableau. Ainsi,
1 i f ( a==b ) {
2 obj t [ 1 0 ] ;
3 ...
4 }
appellera 10 fois le constructeur vide en ligne 2 et dix fois le destructeur en ligne 4.
Dans le cas d’un tableau dynamique, c’est au moment du delete [] que les destructeurs
sont appelés (avant la désallocation du tableau !).
i f ( a==b ) {
o b j ∗ t =new o b j [ n ] ; / / n appels à obj ()
...
delete [ ] t ; / / n appels à ~obj ( ) ;
}
Attention : il est possible d’écrire delete t sans les []. C’est une erreur !
Cette syntaxe est réservée à une autre utilisation du new/delete. L’utiliser
ici a pour conséquence de bien désallouer le tas, mais d’oublier d’appeler les
destructeurs sur les t[i]
.
10.9 Constructeur de copie

Voyons enfin ce fameux constructeur. Il n’a rien de mystérieux. Il s’agit d’un construc-
teur prenant en paramètre un autre objet, en général en référence constante.
Le constructeur de copie :
— Se déclare : obj::obj(const obj& o);
— Est utilisé évidemment par :
obj a;
obj b(a); // b à partir de a
— Mais aussi par :
obj a;
obj b=a; // b à partir de a, synonyme de b(a)
à ne pas confondre avec :
obj a,b;
b=a; // ceci n’est pas un constructeur!
— Et aussi pour construire les paramètres des fonctions et leur valeur de
retour.
Notre programme exemple est enfin complet. En rajoutant :
o b j : : o b j ( c o n s t o b j& o ) {
cout << " copy " ;
}
148
10. Constructeurs et Destructeurs 10.10. Affectation
il affiche :
0 o b j 1 o b j 2 ~ o b j 3 ~ o b j 4 ~ copy ~ 5 o b j 6 copy ~ ~ ~
Nous avons enfin autant d’appels (7) aux constructeurs qu’au destructeur !
Il reste malgré tout à savoir une chose sur ce constructeur, dont nous comprendrons
l’importance par la suite :
Lorsqu’il n’est pas programmé explicitement, le constructeur par copie re-
copie tous les champs de l’objet à copier dans l’objet construit.
Remarquez aussi que lorsqu’on définit soi-même un constructeur, le constructeur vide
par défaut n’existe plus mais le constructeur de copie par défaut existe toujours !
10.10 Affectation
Il reste en fait une dernière chose qu’il est possible de reprogrammer pour un objet :
l’affectation. Si l’affectation n’est pas reprogrammée, alors elle se fait naturellement par
recopie des champs. Pour la reprogrammer, on a recours à l’opérateur =. Ainsi a=b, se
lit a.operator=(b) si jamais celui-ci existe. Rajoutons donc :
void o b j : : o p e r a t o r =( c o n s t o b j&o ) {
cout << " = " ;
}
à notre programme, et il affiche :
0 o b j 1 o b j 2 ~ o b j 3 ~ o b j 4 ~ copy ~ 5 o b j 6 copy ~ = ~ ~
On raffine en général un peu. L’instruction a=b=c; entre trois entiers marche pour
deux raisons :
— Elle se lit a=(b=c);
— L’instruction b=c affecte c à b et retourne la valeur de c
Pour pouvoir faire la même chose entre trois objets, on reprogrammera plutôt l’affec-
tation ainsi :
o b j o b j : : o p e r a t o r =( c o n s t o b j&o ) {
cout << " = " ;
return o ;
}
...
obj a , b , c ;
a=b=c ; / / OK c a r a =( b=c )
ou même ainsi, ce qui dépasse nos connaissances actuelles, mais que nous préconisons
car cela évite de recopier un objet au moment du return :
c o n s t o b j& o b j : : o p e r a t o r =( c o n s t o b j&o ) {
cout << " = " ;
return o ;
}
...
obj a , b , c ;
a=b=c ; / / OK c a r a =( b=c )
149
10.11. Objets avec allocation dynamique 10. Constructeurs et Destructeurs
Un dernier conseil :
Attention à ne pas abuser ! Il n’est utile de reprogrammer le constructeur

par copie et l’opérateur d’affectation que lorsqu’on veut qu’ils fassent autre
chose que leur comportement par défaut a !
a. Contrairement au constructeur vide, qui, lui, n’existe plus dès qu’on définit un autre
constructeur, et qu’il est donc en général indispensable de reprogrammer, même pour repro-
duire son comportement par défaut
10.11 Objets avec allocation dynamique

Tout ce que nous venons de voir est un peu abstrait. Nous allons enfin découvrir à
quoi ça sert. Considérons le programme suivant :
c l as s vect {
int n;
double ∗ t ;
public :
void a l l o u e ( i n t N) ;
void l i b e r e ( ) ;
};
void v e c t : : a l l o u e ( i n t N) {
n=N;
t =new double [ n ] ;
}
void v e c t : : l i b e r e ( ) {
delete [ ] t ;
}
i n t main ( )
{
vect v ;
v . alloue ( 1 0 ) ;
...
v. libere ( ) ;
return 0;
}
10.11.1 Construction et destruction

Il apparaît évidemment que les constructeurs et les destructeurs sont là pour nous
aider :
150
10. Constructeurs et Destructeurs 10.11. Objets avec allocation dynamique
c l as s vect {
int n;
double ∗ t ;
public :
v e c t ( i n t N) ;
~vect ( ) ;
};
v e c t : : v e c t ( i n t N) {
n=N;
t =new double [ n ] ;
}
vect : : ~ vect ( ) {
delete [ ] t ;
}
i n t main ( )
{
vect v ( 1 0 ) ;
...
return 0;
}
Grâce aux constructeurs et au destructeur, nous pouvons enfin laisser les

allocations et les désallocations se faire toutes seules !
10.11.2 Problèmes !
Le malheur est que cette façon de faire va nous entraîner assez loin pour des débu-
tants. Nous allons devoir affronter deux types de problèmes.
Un problème simple
Puisqu’il n’y a qu’un seul destructeur pour plusieurs constructeurs, il va falloir faire
attention à ce qui se passe dans le destructeur. Rajoutons par exemple un constructeur
vide :
vect : : vect ( ) {
}
alors la destruction d’un objet créé à vide va vouloir désallouer un champ t absurde. Il
faudra donc faire, par exemple :
vect : : vect ( ) {
n=0;
}
151
10.11. Objets avec allocation dynamique 10. Constructeurs et Destructeurs
vect : : ~ vect ( ) {
i f (n!=0)
delete [ ] t ;
}
Des problèmes compliqués

Le programme suivant ne marche pas :
i n t main ( )
{
v e c t v ( 1 0 ) ,w( 1 0 ) ;
w=v ;
return 0;
}
Pourquoi ? Parce que l’affectation par défaut recopie les champs de v dans ceux de
w. Du coup, v et w se retrouvent avec les mêmes champs t ! Non seulement ils iront
utiliser les mêmes valeurs, d’où certainement des résultats faux, mais en plus une même
zone du tas va être désallouée deux fois, tandis qu’une autre ne le sera pas 3 !
Il faut alors reprogrammer l’affectation, ce qui n’est pas trivial. On décide en géné-
ral de réallouer la mémoire et de recopier les éléments du tableau :
c o n s t v e c t& v e c t : : o p e r a t o r =( c o n s t v e c t& v ) {
i f (n!=0)
d e l e t e [ ] t ; / / On s e d e s a l l o u e s i n e c e s s a i r e
n=v . n ;
i f (n!=0) {
t =new double [ n ] ; / / R e a l l o c a t i o n e t r e c o p i e
f o r ( i n t i = 0 ; i <n ; i ++)
t [ i ]= v . t [ i ] ;
}
return v ;
}
Cette version ne marche d’ailleurs pas si on fait v=v car alors v est désalloué avant
d’être recopié dans lui-même, ce qui provoque une lecture dans une zone qui vient
d’être désallouée 4 .
10.11.3 Solution !
Des problèmes identiques se posent pour le constructeur de copie. . . Ceci dit, en
factorisant le travail à faire dans quelques petites fonctions privées, la solution n’est
pas si compliquée. Nous vous la soumettons en bloc. Elle peut même servir de schéma
pour la plupart des objets similaires 5 :
3. Ne pas désallouer provoque évidemment des fuites de mémoire. Désallouer deux fois provoque
dans certains cas une erreur.
4. Il suffit de rajouter un test (&v==this) pour repérer ce cas, ce qui nous dépasse un petit peu. . .
5. Ceci n’est que le premier pas vers une série de façon de gérer les objets. Doit-on recopier les ta-
bleaux ? Les partager en faisant en sorte que le dernier utilisateur soit chargé de désallouer ? Etc, etc.
152
10. Constructeurs et Destructeurs 10.11. Objets avec allocation dynamique
3
4 c l a s s vect {
5 / / champs
6 int n;
7 double ∗ t ;
8 // fonctions privées
9 void a l l o c ( i n t N) ;
10 void k i l l ( ) ;
11 void copy ( c o n s t v e c t& v ) ;
12 public :
13 // constructeurs " obligatoires "
14 vect ( ) ;
15 v e c t ( c o n s t v e c t& v ) ;
16 // destructeur
17 ~vect ( ) ;
18 // affectation
19 c o n s t v e c t& o p e r a t o r =( c o n s t v e c t& v ) ;
20 / / constructeurs supplémentaires
21 v e c t ( i n t N) ;
22 };
23
24 void v e c t : : a l l o c ( i n t N) {
25 n=N;
26 i f (n!=0)
27 t =new double [ n ] ;
28 }
29
30 void v e c t : : k i l l ( ) {
31 i f (n!=0)
32 delete [ ] t ;
33 }
34
35 void v e c t : : copy ( c o n s t v e c t& v ) {
36 alloc (v.n ) ;
37 f o r ( i n t i = 0 ; i <n ; i ++) / / OK même s i n==0
38 t [ i ]= v . t [ i ] ;
39 }
40
41 vect : : vect ( ) {
42 alloc (0);
43 }
44
45 v e c t : : v e c t ( c o n s t v e c t& v ) {
46 copy ( v ) ;
47 }
48
153
10.12. Fiche de référence 10. Constructeurs et Destructeurs
49 vect : : ~ vect ( ) {
50 kill ();
51 }
52
53 c o n s t v e c t& v e c t : : o p e r a t o r =( c o n s t v e c t& v ) {
54 i f ( t h i s !=&v ) {
55 kill ();
56 copy ( v ) ;
57 }
58 return v ;
59 }
60
61 v e c t : : v e c t ( i n t N) {
62 a l l o c (N) ;
63 }
64
65 / / Pour t e s t e r c o n s t r u c t e u r d e c o p i e
66 vect f ( vect a ) {
67 return a ;
68 }
69 / / Pour t e s t e r l e r e s t e
70 i n t main ( )
71 {
72 vect a , b ( 1 0 ) , c ( 1 2 ) ,d ;
73 a=b ;
74 a=a ;
75 a=c ;
76 a=d ;
77 a= f ( a ) ;
78 b= f ( b ) ;
79 return 0;
80 }

Boucles ... }
— do { — for(int i=1,j=10;j>i; Clavier
... i=i+2,j=j-3)
} while(!ok); — Debug : F5
...
— int i=1; — Step over : F10
— for (int i=...)
while(i<=100) { for (int j=...) { — Step inside : F11
... //saute cas i==j
i=i+1; — Indent : Ctrl+A,Ctrl+I
if (i==j)
} continue; — Step out : Maj+F11
— for(int i=1;i<=10;i++) ... — Gest. tâches : Ctrl+Maj+Ech
154
10. Constructeurs et Destructeurs 10.12. Fiche de référence

Structures const int m=12; — Surcharge :
— struct Point { void f() { int hasard(int n);
double x,y; n=10; // OK int hasard(int a,
Color c; int i=m; // OK int b);
}; ... double hasard();
... — Conversion : — Opérateurs :
Point a; int i=int(x),j; vect operator+(
a.x=2.3; a.y=3.4; float x=float(i)/j; vect A,vect B) {
a.c=Red; — Pile/Tas ...
Point b={1,2.5,Blue}; }
— Une structure est un objet en- Fonctions ...
tièrement public (→ cf ob- — Définition : vect C=A+B;
jets !) int plus(int a,int b){ — Pile des appels
int c=a+b;
Variables return c; — Itératif/Récursif
— Définition : } — Références constantes (pour
int i; void affiche(int a) { un passage rapide) :
int k,l,m; cout << a << endl; void f(const obj& x){
— Affectation : } ...
i=2; — Déclaration : }
j=i; int plus(int a,int b); void g(const obj& x){
k=l=3; f(x); // OK
— Retour :
— Initialisation : int signe(double x) { }
int n=5,o=n; if (x<0)
— Constantes : Tableaux
return -1;
const int s=12; if (x>0) — Définition :
— Portée : return 1;
return 0; — double x[5],y[5];
int i;
} for(int i=0;i<5;i++)
// i=j; interdit!
void afficher(int x, y[i]=2*x[i];
int j=2;
i=j; // OK! int y) { — const int n=5;
if (j>1) { if (x<0 || y<0) int i[n],j[2*n];
int k=3; return;
if (x>=w || y>=h) — Initialisation :
j=k; // OK!
return; int t[4]={1,2,3,4};
}
DrawPoint(x,y,RED); string s[2]={"ab","c"};
//i=k; interdit!
— Types : } — Affectation :
int i=3; — Appel : int s[3]={1,2,3},t[3];
double x=12.3; int f(int a) { ... } for (int i=0;i<3;i++)
char c=’A’; int g() { ... } t[i]=s[i];
string s="hop"; ... — En paramètre :
bool t=true; int i=f(2),j=g();
float y=1.2f; — void init(int t[4]) {
— Références :
unsigned int j=4; for(int i=0;i<4;i++)
void swap(int& a,
signed char d=-128; t[i]=0;
int& b){
unsigned char d=25; }
int tmp=a;
complex<double> a=b;b=tmp; — void init(int t[],
z(2,3); } int n) {
... for(int i=0;i<n;i++)
— Variables globales : int x=3,y=2; t[i]=0;
int n; swap(x,y); }
155
10.12. Fiche de référence 10. Constructeurs et Destructeurs

Taille variable : ..=y; // OK }
int* t=new int[n]; z=..; // OK ...
... } obj a;
delete[] t; void obj::pour_tous(){ — Objets temporaires :
En paramètre (suite) : x=..; // OK vec vec::operator+(
a_moi(); // OK vec b) {
— void f(int* t,int n){ }
t[i]=... return vec(x+b.x,
void autre(obj A) { y+b.y);
} x=A.x; // OK }
— void alloue(int*& t){ A.a_moi(); // OK ...
t=new int[n]; } c=vec(1,2)
} ... +f(vec(2,3));
2D : int main() {
obj A,B; — Destructeur :
int A[2][3]; obj::~obj() {
A[i][j]=...; A.x=..; //NON
A.z=..; //OK ...
int A[2][3]= }
{{1,2,3},{4,5,6}}; A.a_moi(); //NON
void f(int A[2][2]); A.pour_tous(); //OK — Constructeur de copie :
A.autre(B); //OK obj::obj(const obj& o){
2D dans 1D : ...
— class obj {
int A[2*3]; }
obj operator+(obj B);
A[i+2*j]=...; Utilisé par :
};
Taille variable (suite) : ... - obj b(a);
int *t,*s,n; int main() { - obj b=a;
obj A,B,C; //mieux que obj b;b=a;
Objets - paramètres des fonctions
C=A+B;
— struct obj { - valeur de retour
// C=A.operator+(B)
int x; // champ
— Affectation :
int f(); // méthode — Méthodes constantes :
void obj::f() const{ obj& obj::operator=(
int g(int y);
... const obj&o){
};
} ...
int obj::f() {
void g(const obj& x){ return *this;
int i=g(3); // mon g
x.f(); // OK }
int j=x+i; // mon x
return j; } — Objets avec allocation dyna-
} — Constructeur : mique automatique : cf sec-
... class point { tion 10.11
int main() { int x,y; Compilation séparée
obj a; public:
a.x=3; point(int X,int Y); — #include "vect.h", aussi
int i=a.f(); }; dans vect.cpp
— class obj { point::point(int X, — Fonctions : déclarations dans
int x,y; int Y){ le .h, définitions dans le
void a_moi(); x=X; .cpp
public: y=Y; — Types : définitions dans le .h
int z; }
... — Ne déclarer dans le .h que les
void pour_tous(); fonctions utiles.
void autre(obj A); point a(2,3);
}; — Constructeur vide : — #pragma once au début du
void obj::a_moi() { obj::obj() { fichier.
x=..; // OK ... — Ne pas trop découper. . .
156
10. Constructeurs et Destructeurs 10.12. Fiche de référence

Tests — #include <string> — double x=1/3; // NON!
— Comparaison : using namespace std; int i,j;
== != < > <= >= string s="hop"; x=i/j; // NON!
— Négation : ! char c=s[0]; x=double(i/j); //NON!
int l=s.size();
— Combinaisons : && || — double x[10],y[10];
— #include <ctime> for(int i=1;i<=10;i++)
— if (i==0) j=1;
s=double(clock()) y[i]=2*x[i];//NON
— if (i==0) j=1; /CLOCKS_PER_SEC;
else j=2; — int n=5;
— #include <cmath> int t[n]; // NON
double pi=M_PI;
— if (i==0) { — int f()[4] { // NON!
j=1; Imagine++ int t[4];
k=2; — Voir documentation. . . ...
} return t; // NON!
— bool t=(i==0); Conseils }
if (t) — Nettoyer en quittant. int t[4]; t=f();
j=1; — Erreurs et warnings : cliquer. — int s[3]={1,2,3},t[3];
— switch (i) { — Indenter. t=s; // NON!
case 1:
...; — Ne pas laisser de warning. — int t[2];
...; — Utiliser le debuggeur. t={1,2}; // NON!
break; — Faire des fonctions. — struct Point {
case 2: double x,y;
— Tableaux : pas pour transcrire
case 3: } // NON!
une formule mathématique !
...;
break; — Faire des structures. — Point a;
default: — Faire des fichiers séparés. a={1,2}; // NON!
...; — Le .h doit suffire à l’utilisa- — #include "tp.cpp"//NON
} teur (qui ne doit pas regarder — int f(int t[][]);//NON
Entrées/Sorties le .cpp) int t[2,3]; // NON!
— #include <iostream> — Ne pas abuser du récursif. t[i,j]=...; // NON!
using namespace std; — Ne pas oublier delete. — int* t;
... — Compiler régulièrement. t[1]=...; // NON!
cin >> i >> j; — #include <cassert> — int* t=new int[2];
... int* s=new int[2];
Divers assert(x!=0); s=t; // On perd s!
— i++; y=1/x; delete[] t;
i--; — Faire des objets. delete[] s;//Déjà fait
i-=2;
— Ne pas toujours faire des ob- — int *t,s;// s est int
j+=3;
jets ! // non int*
— j=i%n; // Modulo t=new int[n];
— Penser interface / implémen-
— #include <cstdlib> tation / utilisation. s=new int[n];// NON!
...
— class vec {
i=rand()%n; Erreurs fréquentes
int x,y;
x=rand()/ — Pas de définition de fonction public:
double(RAND_MAX); dans une fonction ! ...
— #include <ctime> — int q=r=4; // NON! };
// Un seul appel ...
srand((unsigned int) — if (i=2) // NON!
if i==2 // NON! vec a={2,3}; // NON
time(0));
if (i==2) then // NON! — vec v=vec(1,2);//NON
— #include <cmath>
— for(int i=0,i<100,i++) vec v(1,2); // OUI
double sqrt(double x);
double cos(double x); // NON! — obj* t=new obj[n];
double sin(double x); — int f() {...} delete t; // manque []
double acos(double x); int i=f; // NON!
157
11. Chaînes de caractères, fichiers
Chapitre 11
Chaînes de caractères, fichiers
Nous commençons avec ce chapitre un tour de tout ce qui est utile et même souvent in-
dispensable et que nous n’avons pas encore vu : chaînes de caractères, fichiers, plus quelques
fonctionnalités utiles. Encore une fois, nous ne verrons pas tout de manière exhaustive, mais
les fonctions les plus couramment utilisées.
Vous en connaissez suffisamment pour réaliser de nombreux programmes. Ce qui

vous manque en général ici, c’est la pratique. Après avoir affronté les exercices tout
faits, vous réalisez que, livrés à vous-même, il vous est difficile de vous en sortir. Alors
lancez-vous ! Tentez de programmer l’un des projets proposés sur la page Web du
cours. Vous constaterez rapidement qu’il vous manque aussi quelques fonctions ou
types de variables usuels. Ce chapitre est là pour y remédier. . .
11.1 Chaînes de caratères

Les chaînes de caractères sont les variables stockant des suites de caractères, c’est-à-
dire du texte. Nous les avons déjà rencontrées :
# include <string >
...
s t r i n g s= " hop " ;
char c=s [ 0 ] ;
i n t l =s . s i z e ( ) ;
Complétons :
1. Les chaînes peuvent êtres comparées. C’est l’ordre alphabétique qui est évidem-
ment utilisé :
if ( s1==s1 ) ...
if ( s1 ! = s2 ) ...
if ( s1 <s2 ) ...
if ( s1 >s2 ) ...
if ( s1 >=s2 ) ...
if ( s1 <=s2 ) ...
11.1. Chaînes de caratères 11. Chaînes de caractères, fichiers
2. On peut chercher un caractère dans un chaîne :

s i z e _ t i =s . f i n d ( ’ h ’ ) ; // p o s i t i o n de ’ h ’ dans s ?
s i z e _ t j =s . f i n d ( ’ h ’ , 3 ) ; / / p o s i t i o n de ’ h ’ dans s
// à p a r t i r de la position 3 ,
// en i g n o r a n t s [0] à s [2]
— Attention c’est le type size_t 1 qui est utilisé et non int. Considérez-le
comme un entier mais pour lequel C++ choisit lui-même sur combien d’oc-
tets il faut le mémoriser. . .
— Si le caractère n’est pas trouvé, find retourne string::npos (une constante,
dont la valeur importe peu).
3. On peut aussi chercher une sous-chaîne :
s i z e _ t i =s . f i n d ( " hop " ) ; / / où e s t " hop " d a n s s ?
s i z e _ t j =s . f i n d ( " hop " , 3 ) ; / / où e s t " hop " d a n s s à p a r t i r
/ / d e l a p o s i t i o n 3?
4. Ajouter une chaîne à la fin d’une autre :

s t r i n g a= " comment " ;
s t r i n g b= " ça va , l e s amis ? " ;
s t r i n g t x t =a+ " " +b ;
5. Extraire une sous chaîne :

s t r i n g s1= " un deux t r o i s " ;
s t r i n g s2= s t r i n g ( s1 , 3 , 4 ) ; / / s o u s c h a î n e d e l o n g u e u r 4
/ / commençant en s 1 [ 3 ] ( i c i " deux " )
6. Attention : la récupération d’une string au clavier coupe la chaîne si l’on appuie

sur la touche "Entrée" mais aussi au premier espace rencontré. Ainsi, si l’on tape
"bonjour les amis", le programme :
string s ;
c i n >> s ; / / J u s q u ’ à " E n t r é e " ou un e s p a c e
récupérera "bonjour" comme valeur de s (et éventuellement "les" puis "amis" si
l’on programme d’autres cin>>t...). Pour récupérer la ligne complète, espaces
compris, il faudra faire un
g e t l i n e ( cin , s ) ; / / Toute l a l i g n e jusqu ’ à " Entrée "
On pourra éventuellement préciser un autre caractère que la fin de ligne :
g e t l i n e ( cin , s , ’ : ’ ) ; / / Tout j u s q u ’ à un ’ : ’ ( non c o m p r i s )
7. Convertir une string en une chaîne au format C : le C mémorise ses chaînes dans
des tableaux de caractères terminés par un 0. Certaines fonctions prennent encore
en paramètre un char∗ ou un const char∗ 2 . Il faudra alors leur passer s . c_str ()
pour convertir une variable s de type string (cf section 11.2.2).
1. En réalité, il faut utiliser le type string::size_type.
2. Nous n’avons pas encore vu le rôle de const avec les tableaux.
160
11. Chaînes de caractères, fichiers 11.2. Fichiers
s t r i n g s= " hop hop " ;

c o n s t char ∗ t =s . c _ s t r ( ) ;
Vous trouverez d’autres fonctions dans l’aide en ligne de votre environnement de déve-
loppement, ou tout simplement proposées par celui-ci quand vous utiliserez les string.
11.2 Fichiers
11.2.1 Principe
Pour lire et écrire dans un fichier, on procède exactement comme avec cout et cin.
On crée simplement une variable de type ofstream pour écrire dans un fichier, ou de
type ifstream pour lire. . .
1. Voici comment faire :
# i n c l u d e <fstream >
...
o f s t r e a m f ( " hop . t x t " ) ;
f << 1 << ’ ’ << 2 . 3 << ’ ’ << " s a l u t " << endl ;
f . close ( ) ;
i f s t r e a m g ( " hop . t x t " ) ;

int i ;
double x ;
string s ;
g >> i >> x >> s ;
g . close ( ) ;
2. Il est bon de vérifier que l’ouverture s’est bien passée. Une erreur fréquente est
de préciser un mauvais nom de fichier : le fichier n’est alors pas ouvert.
i f s t r e a m g ( " . . / data/hop . t x t " ) ;
i f ( ! g . is_open ( ) ) {
cout << " help ! " << endl ;
return 1;
}
(Attention, toujours utiliser le slash /, portable, et non le backslash \ même sous
Windows). On peut aussi avoir besoin de savoir si on est arrivé au bout du fi-
chier :
do {
...
} while ( ! ( g . e o f ( ) ) ;
3. Une fonction (en fait macro du préprocesseur) utile de Imagine++ (dans Com-
mon) est srcPath, qui remplace un chemin relatif en chemin absolu en faisant
précéder le chemin par l’emplacement du dossier contenant le fichier source.
Ainsi, le fichier sera trouvé quel que soit le dossier courant dans lequel est lancé
le programme. Ainsi si notre dossier source est /home/pascal/Test/,
161
11.2. Fichiers 11. Chaînes de caractères, fichiers
i f s t r e a m g ( s r c P a t h ( " hop . t x t " ) ) ;

cherchera le fichier /home/pascal/Test/hop.txt, même si notre programme
se trouve dans le dossier build. L’équivalent pour le type string est stringSrcPath.
4. Un fichier peut s’ouvrir après construction :
ofstream f ;
f . open ( " hop . t x t " ) ;
...
5. Moins fréquent, mais très utile à connaître : on peut écrire dans un fichier direc-
tement la suite d’octets en mémoire qui correspond à une variable ou un tableau.
Le fichier est alors moins volumineux, l’écriture et la lecture plus rapides (pas
besoin de traduire un nombre en une suite de caractères ou l’inverse !)
double x [ 1 0 ] ;
double y ;
o f s t r e a m f ( " hop . bin " , i o s : : b i n a r y ) ;
f . w r i t e ( ( c o n s t char ∗ ) x , 1 0 ∗ s i z e o f ( double ) ) ;
f . w r i t e ( ( c o n s t char ∗)&y , s i z e o f ( double ) ) ;
f . close ( ) ;
...
i f s t r e a m g ( " hop . bin " , i o s : : b i n a r y ) ;
g . read ( ( char ∗ ) x , 1 0 ∗ s i z e o f ( double ) ) ;
g . read ( ( c o n s t char ∗)&y , s i z e o f ( double ) ) ;
g . close ( ) ;
Attention à ne pas oublier le "mode d’ouverture" ios :: binary
11.2.2 Chaînes et fichiers

1. Pour ouvrir un fichier, il faut préciser le nom avec une chaîne au format C. D’où
la conversion. . .
void l i r e ( s t r i n g nom) {
i f s t r e a m f (nom . c _ s t r ( ) ) ; / / Conversion o b l i g a t o i r e . . .
...
}
2. Pour lire une chaîne avec des espaces, même chose qu’avec cin :
getline (g , s ) ;
getline (g , s , ’ : ’ ) ;
3. Enfin, un peu technique mais très pratique : les stringstream qui sont des chaînes
simulant des fichiers virtuels. On les utilise notamment pour convertir une chaîne
en nombre ou l’inverse :
# i n c l u d e <sstream >
s t r i n g s= " 12 " ;
162
11. Chaînes de caractères, fichiers 11.2. Fichiers
stringstream f ;
int i ;
/ / Chaîne v e r s e n t i e r
f << s ; / / On é c r i t l a c h a î n e
f >> i ; / / On r e l i t un e n t i e r ! ( i v a u t 1 2 )
i ++;
/ / Entier vers chaîne
f . c l e a r ( ) ; / / Ne p a s o u b l i e r s i on a d é j à u t i l i s é f
f <> s ; / / On r e l i t une c h a î n e ( s v a u t " 1 3 " )
Notons dans ce dernier cas une fonction plus commode pour convertir une valeur
numérique (int, double, . . .) en string (depuis C++ 2011) : s = std :: to_string ( i ).
11.2.3 Objets et fichiers

Le grand intérêt des << et >> 3 est la possibilité de les redéfinir pour des objets !
C’est technique, mais il suffit de recopier ! Voici comment :
s t r u c t point {
int x , y ;
};
ostream& o p e r a t o r < <( ostream& f , c o n s t p o i n t& p ) {

f << p . x << ’ ’ << p . y ; / / ou q u o i que c e s o i t d ’ a u t r e !
// ( on a d é c i d é i c i d ’ é c r i r e l e s deux
// c o o r d o n n é e s s é p a r é e s p a r un e s p a c e . . . )
return f ;
}
i s t r e a m& o p e r a t o r > >( i s t r e a m& f , p o i n t& p ) {

f >> p . x >> p . y ; / / ou q u o i que c e s o i t d ’ a u t r e !
return f ;
}
...
point p ;
c i n >> p ;
cout <> p ;
3. Ils ont l’air un peu pénibles à utiliser pour le programmeur habitué au printf et scanf du C. On
voit ici enfin leur puissance !
163
11.3. Valeurs par défaut 11. Chaînes de caractères, fichiers
11.3 Valeurs par défaut

11.3.1 Principe
Souvent utile ! On peut donner des valeurs par défaut aux derniers paramètres
d’une fonction, valeurs qu’ils prendront s’ils ne sont pas précisés à l’appel :
void f ( i n t a , i n t b =0 , i n t c =0) {
// ...
}
void g ( ) {
f (12); / / Appelle f (12 ,0 ,0);
f (10 ,2); / / Appelle f (10 ,2 ,0);
f (1 ,2 ,3); / / Appelle f (1 ,2 ,3);
}
S’il y a déclaration puis définition, on ne précise les valeurs par défaut que dans la
déclaration :
void f ( i n t a , i n t b = 0 ) ; / / d é c l a r a t i o n
void g ( ) {
f (12); / / Appelle f (12 ,0);
f (10 ,2); / / Appelle f (10 ,2);
}
void f ( i n t a , i n t b ) { / / ne p a s r e −p r é c i s e r i c i l e b p a r d é f a u t . . .
// ...
}
11.3.2 Utilité
En général, on part d’une fonction :
int f ( int a , int b) {
...
}
Puis, on veut lui rajouter un comportement spécial dans un certain cas :
i n t f ( i n t a , i n t b , bool s p e c i a l ) {
...
}
Plutôt que de transformer tous les anciens appels à f (.,.) en f (.,., false ), il suffit de
faire :
i n t f ( i n t a , i n t b , bool s p e c i a l = f a l s e ) {
...
}
pour laisser les anciens appels inchangés, et uniquement appeler f (.,., true) dans les
futurs cas particuliers qui vont se présenter.
164
11. Chaînes de caractères, fichiers 11.4. Accesseurs
11.3.3 Erreurs fréquentes

Voici les erreurs fréquentes lorsqu’on veut utiliser des valeurs par défaut :
1. Vouloir en donner aux paramètres au milieu de la liste :
void f ( i n t a , i n t b =3 , i n t c ) { / / NON! L e s d e r n i e r s p a r a m è t r e s
/ / Pas c e u x du m i l i e u !
}
2. Engendrer des problèmes de surcharge :

void f ( i n t a ) {
...
}
void f ( i n t a , i n t b =0) { / / P r o b l è m e d e s u r c h a r g e !
... / / On ne s a u r a p a s r é s o u d r e f ( 1 )
}
11.4 Accesseurs
Voici, en cinq étapes, les points utiles à connaître pour faire des accesseurs pratiques
et efficaces.
11.4.1 Référence comme type de retour

Voici une erreur souvent rencontrée, qui fait hurler ceux qui comprennent ce qui se
passe :
int i ; / / Variable globale
int f () {
return i ;
}
...
f ( ) = 3 ; / / Ne v e u t r i e n d i r e ( p a s p l u s que 2=3)
On ne range pas une valeur dans le retour d’une fonction, de même qu’on n’écrit pas
2=3 ! En fait, si ! C’est possible. Mais uniquement si la fonction retourne une référence,
donc un "lien" vers une variable :
int i ; / / Variable globale
i n t& f ( ) {
return i ;
}
...
f ( ) = 3 ; / / OK! Met 3 d a n s i !
Attention : apprendre ça à un débutant est très dangereux. En général, il se dépêche
de commettre l’horreur suivante :
i n t& f ( ) {
i n t i ; / / Var . l o c a l e
165
11.4. Accesseurs 11. Chaînes de caractères, fichiers
r e t u r n i ; / / r é f é r e n c e v e r s une v a r i a b l e q u i va m o u r i r !
/ / C ’ EST GRAVE!
}
...
f ( ) = 3 ; / / NON! ! ! Le i n ’ e x i s t e p l u s . Que va−t− i l s e p a s s e r ? !
11.4.2 Utilisation
Même si un objet n’est pas une variable globale, un champ de cet objet ne meurt
pas en sortant d’une de ses méthodes ! On peut, partant du programme :
c l a s s point {
double x [N] ;
public :
void s e t ( i n t i , double v ) ;
};
void p o i n t : : s e t ( i n t i , double v ) {
x [ i ]= v ;
}
...
point p ;
p. set ( 1 , 2 . 3 ) ;
le transformer en :
c l a s s point {
double x [N] ;
public :
double& element ( i n t i ) ;
};
double& p o i n t : : element ( i n t i ) {
return x [ i ] ;
}
...
point p ;
p . element ( 1 ) = 2 . 3 ;
11.4.3 operator()
Etape suivante : ceci devient encore plus utile quand on connaît operator() qui per-
met de redéfinir les parenthèses :
c l a s s point {
double x [N] ;
public :
double& o p e r a t o r ( ) ( i n t i ) ;
};
double& p o i n t : : o p e r a t o r ( ) ( i n t i ) {
return x [ i ] ;
166
11. Chaînes de caractères, fichiers 11.4. Accesseurs
}
...
point p ;
p ( 1 ) = 2 . 3 ; / / J o l i , non ?
Notez que l’on peut passer plusieurs paramètres, ce qui est utile par exemple pour
les matrices :
c l a s s mat {
double x [M∗N] ;
public :
double& o p e r a t o r ( ) ( i n t i , i n t j ) ;
};
double& mat : : o p e r a t o r ( ) ( i n t i , i n t j ) {
r e t u r n x [ i +M∗ j ] ;
}
...
mat A;
A( 1 , 2 ) = 2 . 3 ;
11.4.4 Surcharge et méthode constante

Nous sommes maintenant face à un problème : le programme précédent ne permet
pas d’écrire :
void f ( mat& A) {
A( 1 , 1 ) = 2 ; / / OK
}
void f ( c o n s t mat& A) {
double x=A( 1 , 1 ) ; / / NON! Le c o m p i l a t e u r ne s a i t p a s que
/ / c e t t e l i g n e ne m o d i f i e r a p a s A!
}
car la méthode operator() n’est pas constante. Il y a heureusement une solution : pro-
grammer deux accesseurs, en profitant du fait qu’entre une méthode et une méthode
constante, il y a surcharge possible, même si elles ont les mêmes paramètres ! Cela
donne :
c l a s s mat {
double x [M∗N] ;
public :
/ / Même nom , mêmes p a r a m è t r e s , m a i s l ’ une e s t ’ c o n s t ’ !
/ / Donc s u r c h a r g e p o s s i b l e
double& o p e r a t o r ( ) ( i n t i , i n t j ) ;
double o p e r a t o r ( ) ( i n t i , i n t j ) c o n s t ;
};
double mat : : o p e r a t o r ( ) ( i n t i , i n t j ) c o n s t {
r e t u r n x [ i +M∗ j ] ;
}
double& mat : : o p e r a t o r ( ) ( i n t i , i n t j ) {
r e t u r n x [ i +M∗ j ] ;
167
11.4. Accesseurs 11. Chaînes de caractères, fichiers
}
void f ( mat& A) {
A( 1 , 1 ) = 2 ; / / OK, a p p e l l e l e p r e m i e r o p e r a t o r ( )
}
void f ( c o n s t mat& A) {
double x=A( 1 , 1 ) ; / / OK, a p p e l l e l e d e u x i è m e
}
11.4.5 "inline"
Principe
Dernière étape : appeler une fonction et récupérer sa valeur de retour est un mécanisme
complexe, donc long. Appeler A(i, j ) au lieu de faire A.x[i+M∗j] est une grande perte de
temps : on passe plus de temps à appeler la fonction A.operator()(i , j ) et à récupérer
sa valeur de retour, qu’à exécuter la fonction elle-même ! Cela pourrait nous conduire à
retourner aux structures en oubliant les classes ! 4
Il existe un moyen de supprimer ce mécanisme d’appel en faisant en sorte que le
corps de la fonction soit recopié dans le code appelant lui-même. Pour cela, il faut
déclarer la fonction inline. Par exemple :
i n l i n e double s q r ( double x ) {
r e t u r n x∗x ;
}
...
double y= s q r ( z − 3 ) ;
fait exactement comme si on avait écrit y=(z−3)(z−3), sans qu’il n’y ait d’appel de
fonction !
Précautions
Bien comprendre ce qui suit :

— Une fonction inline est recompilée à chaque ligne qui l’appelle, ce qui ralentit la
compilation et augmente la taille du programme !
— inline est donc réservé aux fonctions courtes pour lesquelles l’appel est péna-
lisant par rapport au corps de la fonction !
— Si la fonction était déclarée dans un .h et définie dans un .cpp, il faut maintenant
la mettre entièrement dans le .h car l’utilisateur de la fonction a besoin de la
définition pour remplacer l’appel de la fonction par son corps !
— Pour pouvoir exécuter les fonctions pas à pas sous debuggeur, les fonctions inline
sont compilées comme des fonctions normales en mode Debug. Seul le mode Re-
lease profitera donc de l’accélération.
4. Les programmeurs C pourraient aussi être tentés de programmer des "macros" (ie. des raccourcis
avec des #define, ce que nous n’avons pas appris à faire). Celles-ci sont moins puissantes que les
inline car elles ne vérifient pas les types, ne permettent pas d’accéder aux champs privés, etc. Le
programmeur C++ les utilisera avec parcimonie !
168
11. Chaînes de caractères, fichiers 11.5. Assertions
Cas des méthodes

Dans le cas d’une méthode, il faut bien penser à la mettre dans le ficher .h si la
classe était définie en plusieurs fichiers. C’est le moment de révéler ce que nous gar-
dions caché :
Il est possible de DÉFINIR UNE MÉTHODE ENTIÈREMENT DANS LA DÉFINI -
TION DE LA CLASSE , au lieu de seulement l’y déclarer puis placer sa dé-
finition en dehors de celle de la classe. Cependant, ceci n’est pas obliga-
toire a , ralentit la compilation et va à l’encontre de l’idée qu’il faut masquer
le contenu des méthodes à l’utilisateur d’une classe. C’est donc RÉSERVÉ
AUX PETITES FONCTIONS, en général de type inline.
a. Contrairement à ce qu’il faut faire en Java ! Encore une source de mauvaises habitudes
pour le programmeur Java qui se met à C++. . .
Voici ce que cela donne en pratique :

c l a s s mat {
double x [M∗N] ;
public :
i n l i n e double& o p e r a t o r ( ) ( i n t i , i n t j ) {
r e t u r n x [ i +M∗ j ] ;
}
i n l i n e double o p e r a t o r ( ) ( i n t i , i n t j ) c o n s t {
r e t u r n x [ i +M∗ j ] ;
}
};
11.5 Assertions
Rappelons l’existence de la fonction assert () vue en 7.6. Il ne faut pas hésiter à s’en
servir car elle facilite la compréhension du code (répond à la question “quels sont les
présupposés à ce point du programme ?”) et facilite le diagnostic des erreurs. Sachant
qu’elle ne coûte rien en mode Release (car non compilée), il ne faut pas se priver de
l’utiliser. Voici par exemple comment rendre sûrs nos accesseurs :
# include <cassert >
c l a s s mat {
double x [M∗N] ;
public :
i n l i n e double& o p e r a t o r ( ) ( i n t i , i n t j ) {
a s s e r t ( i >=0 && i <M && j >=0 && j <N) ;
r e t u r n x [ i +M∗ j ] ;
}
i n l i n e double o p e r a t o r ( ) ( i n t i , i n t j ) c o n s t {
a s s e r t ( i >=0 && i <M && j >=0 && j <N) ;
r e t u r n x [ i +M∗ j ] ;
}
169
11.6. Types énumérés 11. Chaînes de caractères, fichiers
};
11.6 Types énumérés

C’est une bonne idée de passer par des constantes pour rendre un programme plus
lisible :
c o n s t i n t nord =0 , e s t =1 , sud =2 , o u e s t = 3 ;
void avance ( i n t d i r e c t i o n ) ;
mais il est maladroit de faire ainsi ! Il vaut mieux connaître l’existence des types énumé-
rés :
enum Dir { nord , e s t , sud , o u e s t } ;
void avance ( Dir d i r e c t i o n ) ;
Il s’agit bien de définir un nouveau type, qui, en réalité, masque des entiers. Une pré-
cision : on peut forcer certaines valeurs si besoin. Comme ceci :
enum Code { C10 =200 ,
C11 =231 ,
C12 =240 ,
C13 , / / Vaudra 241
C14 } ; / / " 242
Voilà. C’est tout pour aujourd’hui ! Nous continuerons au prochain chapitre. Il est donc
temps de retrouver notre célèbre fiche de référence. . .

Boucles ... }
— do { — for(int i=1,j=10;j>i; Clavier
... i=i+2,j=j-3)
} while(!ok); — Debug : F5
...
— int i=1; — Step over : F10
— for (int i=...)
while(i<=100) { for (int j=...) { — Step inside : F11
... //saute cas i==j
i=i+1; — Indent : Ctrl+A,Ctrl+I
if (i==j)
} continue; — Step out : Maj+F11
— for(int i=1;i<=10;i++) ... — Gest. tâches : Ctrl+Maj+Ech
170
11. Chaînes de caractères, fichiers 11.7. Fiche de référence

Structures bool t=true; ...;
— struct Point { float y=1.2f; ...;
double x,y; unsigned int j=4; break;
Color c; signed char d=-128; case 2:
}; unsigned char d=25; case 3:
... complex<double> ...;
Point a; z(2,3); break;
a.x=2.3; a.y=3.4; default:
a.c=Red; — Variables globales : ...;
Point b={1,2.5,Blue}; int n; }
const int m=12;
— Une structure est un objet en- Conseils
void f() {
tièrement public (→ cf ob-
n=10; // OK — Nettoyer en quittant.
jets !)
int i=m; // OK — Erreurs et warnings : cliquer.
Variables ...
— Indenter.
— Conversion :
— Définition :
int i=int(x),j; — Ne pas laisser de warning.
int i;
float x=float(i)/j; — Utiliser le debuggeur.
int k,l,m;
— Pile/Tas
— Affectation : — Faire des fonctions.
i=2; — Type énuméré :
enum Dir{N,E,S,W}; — Tableaux : pas pour transcrire
j=i; une formule mathématique !
k=l=3; void avance(Dir d);
— Faire des structures.
— Initialisation : Tests
int n=5,o=n; — Faire des fichiers séparés.
— Comparaison :
— Constantes : == != < > <= >= — Le .h doit suffire à l’utilisa-
const int s=12; — Négation : ! teur (qui ne doit pas regarder
le .cpp)
— Portée : — Combinaisons : && ||
int i; — if (i==0) j=1; — Ne pas abuser du récursif.
// i=j; interdit! — Ne pas oublier delete.
— if (i==0) j=1;
int j=2;
else j=2; — Compiler régulièrement.
i=j; // OK!
if (j>1) { — #include <cassert>
int k=3; — if (i==0) { ...
j=k; // OK! j=1; assert(x!=0);
} k=2; y=1/x;
//i=k; interdit! }
— Faire des objets.
— Types : — bool t=(i==0);
int i=3; if (t) — Ne pas toujours faire des ob-
double x=12.3; j=1; jets !
char c=’A’; — switch (i) { — Penser interface / implémen-
string s="hop"; case 1: tation / utilisation.
171
11.7. Fiche de référence 11. Chaînes de caractères, fichiers

Fonctions } for (int i=0;i<3;i++)
— Définition : ... t[i]=s[i];
int plus(int a,int b){ vect C=A+B; — En paramètre :
int c=a+b; — Pile des appels — void init(int t[4]) {
return c; — Itératif/Récursif for(int i=0;i<4;i++)
} t[i]=0;
void affiche(int a) { — Références constantes (pour
un passage rapide) : }
cout << a << endl;
} void f(const obj& x){ — void init(int t[],
... int n) {
— Déclaration : } for(int i=0;i<n;i++)
int plus(int a,int b); void g(const obj& x){ t[i]=0;
— Retour : f(x); // OK }
int signe(double x) { }
— Taille variable :
if (x<0) — Valeurs par défaut : int* t=new int[n];
return -1; void f(int a,int b=0); ...
if (x>0) void g() { delete[] t;
return 1; f(12); // f(12,0);
return 0; — En paramètre (suite) :
f(10,2);// f(10,2);
} } — void f(int* t,int n){
void afficher(int x, void f(int a,int b) { t[i]=...
int y) { // ... }
if (x<0 || y<0) } — void alloue(int*& t){
return;
— Inline (appel rapide) : t=new int[n];
if (x>=w || y>=h)
inline double }
return;
DrawPoint(x,y,RED); sqr(double x) { — 2D :
} return x* x; int A[2][3];
} A[i][j]=...;
— Appel : ... int A[2][3]=
int f(int a) { ... } double y=sqr(z-3); {{1,2,3},{4,5,6}};
int g() { ... }
— Référence en retour : void f(int A[2][2]);
...
int i=f(2),j=g(); int i; // Var. globale — 2D dans 1D :
int& f() { int A[2*3];
— Références : return i; A[i+2*j]=...;
void swap(int& a, }
int& b){ — Taille variable (suite) :
...
int tmp=a; int *t,*s,n;
f()=3; // i=3!
a=b;b=tmp;
} Compilation séparée
Tableaux
... — #include "vect.h", aussi
— Définition :
int x=3,y=2; dans vect.cpp
swap(x,y); — double x[5],y[5];
for(int i=0;i<5;i++) — Fonctions : déclarations dans
— Surcharge : y[i]=2*x[i]; le .h, définitions dans le
int hasard(int n); .cpp
int hasard(int a, — const int n=5;
int i[n],j[2*n]; — Types : définitions dans le .h
int b);
double hasard(); — Initialisation : — Ne déclarer dans le .h que les
int t[4]={1,2,3,4}; fonctions utiles.
— Opérateurs :
vect operator+( string s[2]={"ab","c"}; — #pragma once au début du
vect A,vect B) { — Affectation : fichier.
... int s[3]={1,2,3},t[3]; — Ne pas trop découper. . .
172
11. Chaînes de caractères, fichiers 11.7. Fiche de référence

Objets void g(const obj& x){ double *x;
— struct obj { x.f(); // OK public:
int x; // champ } double& operator()
int f(); // méthode — Constructeur : (int i,int j){
int g(int y); class point { assert(i>=0 ...);
}; int x,y; return x[i+M*j];
int obj::f() { public: }
int i=g(3); // mon g point(int X,int Y); double operator()
int j=x+i; // mon x }; (int i,int j)const{
return j; point::point(int X, assert(i>=0 ...);
} int Y){ return x[i+M*j];
... x=X; }
int main() { y=Y; ...
obj a; }
a.x=3; Divers
...
int i=a.f(); point a(2,3); — i++;
— class obj { — Constructeur vide : i--;
int x,y; obj::obj() { i-=2;
void a_moi(); ... j+=3;
public: } — j=i%n; // Modulo
int z; ...
void pour_tous(); obj a; — #include <cstdlib>
void autre(obj A); — Objets temporaires : ...
}; vec vec::operator+( i=rand()%n;
void obj::a_moi() { vec b) { x=rand()/
x=..; // OK return vec(x+b.x, double(RAND_MAX);
..=y; // OK y+b.y); — #include <ctime>
z=..; // OK } // Un seul appel
} ... srand((unsigned int)
void obj::pour_tous(){ c=vec(1,2) time(0));
x=..; // OK +f(vec(2,3));
a_moi(); // OK — #include <cmath>
— Destructeur : double sqrt(double x);
}
obj::~obj() { double cos(double x);
void autre(obj A) {
... double sin(double x);
x=A.x; // OK
} double acos(double x);
A.a_moi(); // OK
} — Constructeur de copie :
... obj::obj(const obj& o){ — #include <string>
... using namespace std;
int main() {
} string s="hop";
obj A,B;
Utilisé par : char c=s[0];
A.x=..; //NON
- obj b(a); int l=s.size();
A.z=..; //OK
- obj b=a; if (s1==s1) ...
A.a_moi(); //NON
//mieux que obj b;b=a; if (s1!=s2) ...
A.pour_tous(); //OK
- paramètres des fonctions if (s1<s2) ...
A.autre(B); //OK
- valeur de retour size_t i=s.find(’h’),
— class obj { j=s.find(’h’,3);
obj operator+(obj B); — Affectation :
k=s.find("hop");
}; obj& obj::operator=(
l=s.find("hop",3);
... const obj&o){
a="comment";
int main() { ...
b="ça va?";
obj A,B,C; return *this;
txt=a+" "+b;
C=A+B; }
s1="un deux trois";
// C=A.operator+(B) — Objets avec allocation dyna- s2=string(s1,3,4);
— Méthodes constantes : mique automatique : cf sec- getline(cin,s);
void obj::f() const{ tion 10.11 getline(cin,s,’:’);
... — Accesseurs : const char *t=s.c_str();
} class mat {
173
11.7. Fiche de référence 11. Chaînes de caractères, fichiers

#include <ctime> f << s; f >> i; — Point a;
s=double(clock()) // Entier vers chaîne a={1,2}; // NON!
/CLOCKS_PER_SEC; f.clear();
— #include "tp.cpp"//NON
#include <cmath> f << i; f >> s; ⇔
s = std::to_string(i); — int f(int t[][]);//NON
double pi=M_PI;
— ostream& operator<<( int t[2,3]; // NON!
Entrées/Sorties ostream& f, t[i,j]=...; // NON!
— #include <iostream> const point&p){ — int* t;
using namespace std; f<<p.x<<’ ’<< p.y; t[1]=...; // NON!
... return f;
cout <<"I="<<i<<endl; } — int* t=new int[2];
cin >> i >> j; istream& operator>>( int* s=new int[2];
— #include <fstream> istream& f,point& p){ s=t; // On perd s!
using namespace std; f>>p.x>>p.y; delete[] t;
ofstream f("hop.txt"); return f; delete[] s;//Déjà fait
f << 1 << ’ ’ << 2.3; } — int *t,s;// s est int
f.close(); // non int*
Erreurs fréquentes
ifstream g("hop.txt"); t=new int[n];
if (!g.is_open()) { — Pas de définition de fonction s=new int[n];// NON!
return 1; dans une fonction !
— class vec {
} — int q=r=4; // NON!
int x,y;
int i; — if (i=2) // NON! public:
double x; if i==2 // NON! ...
g >> i >> x; if (i==2) then // NON! };
g.close();
— for(int i=0,i<100,i++) ...
— do { // NON! vec a={2,3}; // NON
...
— int f() {...} — vec v=vec(1,2);//NON
} while (!(g.eof());
int i=f; // NON! vec v(1,2); // OUI
— ofstream f; — double x=1/3; // NON!
f.open("hop.txt"); int i,j; — obj* t=new obj[n];
— double x[10],y; x=i/j; // NON! delete t; // manque []
ofstream f("hop.bin", x=double(i/j); //NON!
ios::binary); — double x[10],y[10]; — //NON!
f.write((const char*)x, for(int i=1;i<=10;i++) void f(int a=2,int b);
10*sizeof(double)); y[i]=2*x[i];//NON
f.write((const char*)&y, — void f(int a,int b=0);
sizeof(double)); — int n=5; void f(int a);// NON!
f.close(); int t[n]; // NON
— Ne pas tout mettre inline !
ifstream g("hop.bin", — int f()[4] { // NON!
ios::binary); int t[4]; — int f() {
g.read((char*)x, ... ...
10*sizeof(double)); return t; // NON! }
g.read((const char*)&y, } f()=3; // HORREUR!
sizeof(double)); int t[4]; t=f(); — int& f() {
g.close(); — int s[3]={1,2,3},t[3]; int i;
— string s; t=s; // NON! return i;
ifstream f(s.c_str()); — int t[2]; }
— #include <sstream> t={1,2}; // NON! f()=3; // NON!
using namespace std; — struct Point {
Imagine++
stringstream f; double x,y;
// Chaîne vers entier } // NON! — Voir documentation. . .
174
12. Fonctions et classes paramétrées (templates)
Chapitre 12
Fonctions et classes paramétrées

(templates)
Nous continuons dans ce chapitre un inventaire de diverses choses utiles. Parmi elles, les
structures de données de la STL (Standard Template Library) nécessiteront la compréhension
des template. Nous aborderons donc cet aspect intéressant du C++.
12.1 template
12.1.1 Principe
Considérons la fonction classique pour échanger deux variables :
void echange ( i n t& a , i n t& b ) {
i n t tmp ;
tmp=a ;
a=b ;
b=tmp ;
}
...
int i , j ;
...
echange ( i , j ) ;
Si nous devions maintenant échanger deux variables de type double, il faudrait ré-
écrire une autre fonction echange(), identique aux définitions de type près. Heureuse-
ment, le C++ offre la possibilité de définir une fonction avec un type générique, un peu
comme un type variable, que le compilateur devra "instancier" au moment de l’appel
de la fonction en un type précis. Cette "programmation générique" se fait en définissant
un "template" :
/ / Echange deux v a r i a b l e s d e n ’ i m p o r t e q u e l t y p e T
t e m p l a t e <typename T>
void echange ( T& a , T& b ) {
T tmp ;
12.1. template 12. Fonctions et classes paramétrées (templates)
tmp=a ;
a=b ;
b=tmp ;
}
...
i n t a =2 , b = 3 ;
double x = 2 . 1 , y = 2 . 3 ;
echange ( a , b ) ; / / " i n s t a n c i e " T en i n t
echange ( x , y ) ; / / " i n s t a n c i e " T en d o u b l e
...
Autre exemple :
/ / Maximum d e deux v a r i a b l e s ( a c o n d i t i o n que o p e r a t o r > ( ) e x i s t e

/ / pour l e t y p e T)
T maxi ( T a , T b ) {
r e t u r n ( a>b ) ? a : b ;
}
La déclaration typename T précise le type générique. On peut en préciser plusieurs :
/ / C h e r c h e e 1 d a n s l e t a b l e a u t a b 1 e t met
/ / d a n s e 2 l ’ e l e m e n t d e t a b 2 d e meme i n d i c e
/ / R e n v o i e f a l s e s i non t r o u v é
t e m p l a t e <typename T1 , typename T2>
bool cherche ( T1 e1 , T2& e2 , c o n s t T1∗ tab1 , c o n s t T2∗ tab2 , i n t n ) {
f o r ( i n t i = 0 ; i <n ; i ++)
i f ( t a b 1 [ i ]== e1 ) {
e2= t a b 2 [ i ] ;
return true ;
}
return f a l s e ;
}
...
s t r i n g noms [ 3 ] = { " j e a n " , " p i e r r e " , " paul " } ;
i n t ages [ 3 ] = { 2 1 , 2 5 , 1 5 } ;
...
s t r i n g nm= " p i e r r e " ;
i n t ag ;
i f ( cherche (nm, ag , noms , ages , 3 ) )
cout << nm << " a " << ag << " ans " << endl ;
...
12.1.2 template et fichiers

Il faut bien comprendre que
176
12. Fonctions et classes paramétrées (templates) 12.1. template
Le compilateur ne fabrique pas une fonction "magique" qui arrive à tra-

vailler sur plusieurs types ! Il crée en réalité autant de fonctions qu’il y a
d’utilisations de la fonction générique avec des types différents (ie. d’ins-
tanciations)
Pour ces raisons :

1. Faire des fonctions template ralentit la compilation et augmente la taille des pro-
grammes.
2. On ne peut plus mettre la déclaration dans un fichier d’en-tête et la définition
dans un fichier .cpp, car tous les fichiers utilisateurs doivent connaître aussi la
définition. Du coup, la règle est de tout mettre dans le fichier d’en-tête 1 .
12.1.3 Classes
Il est fréquent qu’une définition de classe soit encore plus utile si elle est générique.
C’est possible. Mais attention ! Dans le cas des fonctions, c’est le compilateur qui dé-
termine tout seul quels types sont utilisés. Dans le cas des classes, c’est l’utilisateur qui
doit préciser en permanence avec la syntaxe obj<type> le type utilisé :
/ / P a i r e d e deux v a r i a b l e s d e t y p e T
class paire {
T x[2];
public :
// constructeurs
paire ( ) ;
p a i r e ( T A, T B ) ;
// accesseurs
T operator ( ) ( i n t i ) const ;
T& o p e r a t o r ( ) ( i n t i ) ;
};
p a i r e <T > : : p a i r e ( ) {
}
p a i r e <T > : : p a i r e ( T A, T B ) {
x [ 0 ] =A; x [ 1 ] = B ;
}
T p a i r e <T > : : o p e r a t o r ( ) ( i n t i ) c o n s t {
a s s e r t ( i ==0 || i = = 1 ) ;
1. Ceci est gênant et va à l’encontre du principe consistant à mettre les déclarations dans le .h et à
masquer les définitions dans le .cpp. Cette remarque a déjà été formulée pour les fonctions inline. Le
langage prévoit une solution avec le mot clé export, mais les compilateurs actuels n’implémentent pas
encore cette fonctionnalité !
177
return x [ i ] ;
}
T& p a i r e <T > : : o p e r a t o r ( ) ( i n t i ) {
a s s e r t ( i ==0 || i = = 1 ) ;
return x [ i ] ;
}
...
paire <int > p ( 1 , 2 ) , r ;
i n t i =p ( 1 ) ;
p a i r e <double > q ;
q(1)=2.2;
...
Dans le cas de la classe très simple ci-dessus, on aura recours aux fonctions inline vues
en 11.4.5 :
/ / P a i r e d e deux v a r i a b l e s d e t y p e T
/ / F o n c t i o n s c o u r t e s e t r a p i d e s en i n l i n e
class paire {
T x[2];
public :
// constructeurs
inline paire ( ) { }
i n l i n e p a i r e ( T A, T B ) { x [ 0 ] =A; x [ 1 ] = B ; }
// accesseurs
i n l i n e T operator ( ) ( i n t i ) const {
a s s e r t ( i ==0 || i = = 1 ) ;
return x [ i ] ;
}
i n l i n e T& o p e r a t o r ( ) ( i n t i ) {
a s s e r t ( i ==0 || i = = 1 ) ;
return x [ i ] ;
}
};
Lorsque plusieurs types sont génériques, on les sépare par une virgule :
/ / P a i r e d e deux v a r i a b l e s d e t y p e s d i f f é r e n t s
t e m p l a t e <typename S , typename T>
class paire {
public :
/ / Tout en p u b l i c p o u r s i m p l i f i e r
S x;
T y;
// constructeurs
inline paire ( ) { }
i n l i n e p a i r e ( S X , T Y) { x=X ; y=Y ; }
};
178
...
p a i r e P ( 1 , 2 . 3 ) ;
p a i r e < s t r i n g , i n t > Q;
Q. x= " p i e r r e " ;
Q. y = 2 5 ;
...
Enfin, on peut aussi rendre générique le choix d’un entier :
/ / n−u p l e t d e v a r i a b l e s d e t y p e T
/ / A t t e n t i o n : c h a q u e n u p l e t <T , N> s e r a un t y p e d i f f é r e n t
t e m p l a t e <typename T , i n t N>
c l a s s nuplet {
T x [N] ;
public :
// accesseurs
i n l i n e T operator ( ) ( i n t i ) const {
a s s e r t ( i >=0 && i <N) ;
return x [ i ] ;
}
i n l i n e T& o p e r a t o r ( ) ( i n t i ) {
a s s e r t ( i >=0 && i <N) ;
return x [ i ] ;
}
};
...
nuplet A;
A( 1 ) = 3 ;
nuplet < s t r i n g ,2 > B ;
B(1)= " pierre " ;
...
Les fonctions doivent évidemment s’adapter :
t e m p l a t e <typename T , i n t N>
T somme( nuplet <T ,N> u ) {
T s=u ( 0 ) ;
f o r ( i n t i = 1 ; i <N; i ++)
s+=u ( i ) ;
return s ;
}
...
nuplet <double ,3 > C ;
...
cout << somme(C) << endl ;
...
Au regard de tout ça, on pourrait être tenté de mettre des template partout. Et bien,
non !
179
Les templates sont délicats à programmer, longs à compiler, etc. Il ne faut

pas en abuser ! Il vaut mieux plutôt commencer des classes ou des fonctions
sans template. On ne les rajoute que lorsqu’apparaît le besoin de réutiliser
l’existant avec des types différents. Et répétons-le encore une fois : le compi-
lateur crée une nouvelle classe ou une nouvelle fonction à chaque nouvelle
valeur (instanciation) des types ou des entiers génériques a .
a. Les nuplets ci-dessus, n’ont donc rien-à-voir avec des tableaux de taille variables. Tout
se passe comme si on avait programmé des tableaux de taille constante pour plusieurs valeurs
de la taille.
12.1.4 STL
Les template sont délicats à programmer, mais pas à utiliser. Le C++ offre un certain
nombre de fonctions et de classes utilisant les template. Cet ensemble est communé-
ment désigné sous le nom de STL (Standard Template Library). Vous en trouverez la
documentation complète sur Internet. Nous exposons ci-dessous quelques exemples
qui devraient pouvoir servir de point de départ et faciliter la compréhension de la do-
cumentation.
Des fonctions simples comme min et max sont définies de façon générique :
i n t i =max ( 1 , 3 ) ;
double x=min ( 1 . 2 , 3 . 4 ) ;
Attention : une erreur classique consiste à appeler max(1,2.3) : le compilateur l’inter-
prète comme le max d’un int et d’un double ce qui provoque une erreur ! Il faut taper
max(1.,2.3).
Les complexes sont eux-aussi génériques, laissant variable le choix du type de leurs
parties réelle et imaginaire :
# i n c l u d e <complex>
...
complex<double > z1 ( 1 . 1 , 3 . 4 ) , z2 ( 1 , 0 ) , z3 ;
z3=z1+z2 ;
cout << z3 << endl ;
double a=z3 . r e a l ( ) , b=z3 . imag ( ) ;
double m=abs ( z3 ) ; / / module
double th=arg ( z3 ) ; / / argument
Les couples sont aussi offerts par la STL :
p a i r P ( 2 , " hop " ) ;
P . f i r s t =3;
P . second= " hop " ;
Enfin, un certain nombre de structures de données sont fournies et s’utilisent suivant
un même schéma. Voyons l’exemple des listes :
# include < l i s t >
...
l i s t <int > l ; / / l =[]
180
l . p u sh _ f ro n t ( 2 ) ; // l =[2]
l . p u sh _ f ro n t ( 3 ) ; // l =[3 ,2]
l . push_back ( 4 ) ; // l =[3 ,2 ,4]
l . p u sh _ f ro n t ( 5 ) ; // l =[5 ,3 ,2 ,4]
l . p u sh _ f ro n t ( 2 ) ; // l =[2 ,5 ,3 ,2 ,4]
Pour désigner un emplacement dans une liste, on utilise un itérateur. Pour désigner un
emplacement en lecture seulement, on utilise un itérateur constant. Le ’∗’ sert ensuite
à accéder à l’élément situé à l’emplacement désigné par l’itérateur. Seule difficulté : le
type de ces itérateurs est un peu compliqué à taper 2 :
l i s t <int > : : c o n s t _ i t e r a t o r i t ;
i t = l . begin ( ) ; / / P o i n t e v e r s l e d é b u t d e l a l i s t e
cout << ∗ i t << endl ; / / a f f i c h e 2
i t = l . f i n d ( 3 ) ; / / P o i n t e v e r s l ’ e n d r o i t ou s e t r o u v e
/ / l e premier 3
i f ( i t ! = l . end ( ) )
cout << " 3 e s t dans l a l i s t e " << endl ;
l i s t <int > : : i t e r a t o r i t 2 ;
i t 2 = l . f i n d ( 3 ) ; / / P o i n t e v e r s l ’ e n d r o i t ou s e t r o u v e
/ / l e premier 3
∗ i t =6; / / maintenant l =[2 ,5 ,6 ,2 ,4]
Les itérateurs servent également à parcourir les listes (d’où leur nom !) :
/ / P a r c o u r t e t a f f i c h e une l i s t e
void a f f i c h e ( l i s t <T> l ) {
cout << " [ " ;
f o r ( l i s t <T > : : c o n s t _ i t e r a t o r i t = l . begin ( ) ; i t ! = l . end ( ) ; i t ++)
cout << ∗ i t << ’ ’ ;
cout << ’ ] ’ << endl ;
}
/ / R e m p l a c e a p a r b d a n s une l i s t e
void remplace ( l i s t <T>& l , T a , T b ) {
f o r ( l i s t <T > : : i t e r a t o r i t = l . begin ( ) ; i t ! = l . end ( ) ; i t ++)
i f ( ∗ i t ==a )
∗ i t =b ;
}
...
affiche ( l ) ;
remplace ( l , 2 , 1 ) ; / / m a i n t e n a n t l = [ 1 , 5 , 3 , 1 , 4 ]
...
Enfin, on peut appeler des algorithmes comme le tri de la liste :
l . sort ( ) ;
affiche ( l ) ;
2. Nous n’avons pas vu comment définir de nouveaux types cachés dans des classes ! C’est ce qui est
fait ici. . .
181
12.2. Opérateurs binaires 12. Fonctions et classes paramétrées (templates)
Sur le même principe que les listes, vous trouverez dans la STL :
— Les piles ou stack (Last In First Out).
— Les files ou queue (First In First Out).
— Les ensembles ou set (pas deux fois le même élément).
— Les vecteurs ou vector (tableaux de taille variable).
— Les tas ou heap (arbres binaires de recherche).
— Les tables ou map (table de correspondance clé/valeur).
— Et quelques autres encore. . .
Le reste de ce chapitre regroupe quelques notions utiles mais non fondamentales.
Elles vous serviront probablement plus pour comprendre des programmes déjà écrits
que dans vos propres programmes.
12.2 Opérateurs binaires

Parmi les erreurs classiques, il y a évidemment celle qui consiste à remplacer
i f ( i ==0)
...
par
i f ( i =0) / / NON! ! !
...
qui range 0 dans i puis considère 0 comme un booléen, c’est à dire false . Une autre
erreur fréquente consiste à écrire
i f ( i ==0 & j ==2) / / NON! ! !
...
au lieu de
i f ( i ==0 && j ==2)
...
Cette erreur n’est possible que parce que & existe. Il s’agit de opérateur binaire "ET"
sur des entiers. Il est défini ainsi : effectuer a&b revient à considérer l’écriture de a et
de b en binaire puis à effectuer un "ET" bit par bit (avec la table 1&1 donne 1 ; 1&0, 0&1
et 0&0 donnent 0). Par exemple : 13&10 vaut 8 car en binaire 1101&1010 vaut 1000.
Il existe ainsi toute une panoplie d’opérateurs binaires :
symbole utilisation nom résultat exemple

& a&b et 1&1=1, 0 sinon 13&10=8
| a|b ou 0|0=0, 1 sinon 13|10=15
^ a^b ou exclusif1^0=0^1=1, 0 sinon 13^10=7
>> a>>n décalage à décale les bits de a n fois vers la 13>>2=3
droite droite et comble à gauche avec des 0
(les n premiers de droite sont perdus)
<< a<<n décalage à décale les bits de a n fois vers la 5<<2=20
gauche gauche et comble à droite avec des 0
~ ~a complément ~1=0, ~0=1 ~13=−14
182
12. Fonctions et classes paramétrées (templates) 12.3. Valeur conditionnelle
Remarques :
— Ces instructions sont particulièrement rapides car simples pour le processeur.
— Le fait que a^b existe est aussi source de bugs (il ne s’agit pas de la fonction
puissance !)
— Le résultat de ~ dépend en fait du type : si par exemple i est un entier non signé
sur 8 bits valant 13, alors ~i vaut 242, car ~00001101 vaut 11110010.
En pratique, tout cela ne sert pas à faire joli ou savant, mais à manipuler les nombres
bit par bit. Ainsi, il arrive souvent qu’on utilise un int pour mémoriser un certain
nombre de propriétés en utilisant le moins possible de mémoire avec la convention
que la propriété n est vraie ssi le neme bit de l’entier est à 1. Un seul entier de 32 bits
pourra par ainsi mémoriser 32 propriétés là où il aurait fallu utiliser 32 variables de
type bool. Voici comment on utilise les opérateurs ci-dessus pour manipuler les bits en
question :
i|=(1<<n) passe à 1 le bit n de i

i&=~(1<<n) passe à 0 le bit n de i
i^=(1<<n) inverse le bit n de i
if ( i&(1<<n)) vrai ssi le bit n de i est à 1
Il existe aussi d’autres utilisations fréquentes des opérateurs binaires, non pour des
raisons de gain de place, mais pour des raisons de rapidité :
(1<<n) vaut 2n (sinon il faudrait faire int (pow(2.,n)) !)

( i>>1) calcule i/2 rapidement
( i>>n) calcule i/2n rapidement
( i&255) calcule i%256 rapidement (idem pour toute puissance de 2)
12.3 Valeur conditionnelle

Il arrive qu’on ait à choisir entre deux valeurs en fonction du résultat d’un test. Une
construction utile est alors :
( t e s t )? val1 : val2
qui vaut val1 si test est vrai et val2 sinon. Ainsi

i f ( x>y )
maxi=x ;
else
maxi=y ;
pourra être remplacé par :

maxi =( x>y ) ? x : y ;
Il ne faut pas abuser de cette construction sous peine de programme illisible !
183
12.4. Boucles et break 12. Fonctions et classes paramétrées (templates)
12.4 Boucles et break

Nous avons déjà rencontré à la section 8.4 l’instruction continue qui saute la fin
d’une boucle et passe au tour d’après. Très utile aussi, la commande break sort de la boucle
en ignorant tout ce qu’il restait à y faire. Ainsi le programme :
bool a r r e t e r = f a l s e ;
f o r ( i n t i = 0 ; i <N && ! a r r e t e r ; i ++) {
A;
i f (B)
a r r e t e r=true ;
else {
C;
i f (D)
a r r e t e r=true ;
else {
E;
}
}
}
devient de façon plus lisible et plus naturelle :
f o r ( i n t i = 0 ; i <N; i ++) {
A;
i f (B)
break ;
C;
i f (D)
break ;
E;
}
Questions récurrentes des débutants :
1. break ne sort pas d’un if !
if (...) {
...;
if ( . . . )
break ; / / NON! ! ! Ne s o r t p a s du i f ! ( m a i s é v e n t u e l l e m e n t
/ / d ’ un f o r q u i s e r a i t a u t o u r . . . )
...
}
2. break ne sort que de la boucle courante, pas des boucles autour :

f o r ( i n t i = 0 ; i <N; i ++) {
...
f o r ( i n t j = 0 ; j <M; j ++) {
...
if ( . . . )
break ; / / t e r m i n e l a b o u c l e en j e t p a s s e donc
184
12. Fonctions et classes paramétrées (templates) 12.5. Variables statiques
/ / en l i g n e 10 ( p a s en l i g n e 1 2 )
...
}
...
}
...
3. break et continue marchent évidemment avec while et do . . . while de la

même façon qu’avec for.
12.5 Variables statiques

Il arrive souvent qu’on utilise une variable globale pour mémoriser de façon per-
manente une valeur qui n’intéresse qu’une seule fonction :
/ / F o n c t i o n random q u i a p p e l l e s r a n d ( ) t o u t e s e u l e
/ / au p r e m i e r a p p e l . . .
bool f i r s t = t r u e ;
double random ( ) {
if ( first ) {
first=false ;
srand ( ( unsigned i n t ) time ( 0 ) ) ;
}
r e t u r n double ( rand ( ) ) /RAND_MAX;
}
Le danger est alors que tout le reste du programme voie cette variable globale et l’uti-
lise ou la confonde avec une autre variable globale. Il est possible de cacher cette variable
dans la fonction grâce au mot clé static placé devant la variable :
/ / F o n c t i o n random q u i a p p e l l e s r a n d ( ) t o u t e s e u l e
/ / au p r e m i e r a p p e l . . . a v e c s a v a r i a b l e g l o b a l e
/ / masquée à l ’ i n t é r i e u r
double random ( ) {
s t a t i c bool f i r s t = t r u e ; / / Ne p a s o u b l i e r s t a t i c !
if ( first ) {
first=false ;
srand ( ( unsigned i n t ) time ( 0 ) ) ;
}
r e t u r n double ( rand ( ) ) /RAND_MAX;
}
Attention : il s’agit bien d’une variable globale et non d’une variable locale. Une
variable locale mourrait à la sortie de la fonction, ce qui dans l’exemple précédent
donnerait un comportement non désiré !
NB : Il est aussi possible de cacher une variable globale dans une classe, toujours
grâce à static . Nous ne verrons pas comment et renvoyons le lecteur à la documenta-
tion du C++.
185
12.6. const et tableaux 12. Fonctions et classes paramétrées (templates)
12.6 const et tableaux
Nous avons vu malgré nous const char ∗ comme paramètre de certaines fonctions
(ouverture de fichier par exemple). Il nous faut donc l’expliquer : il ne s’agit pas d’un
pointeur de char qui serait constant mais d’un pointeur vers des char qui sont constants ! Il
faut donc retenir que :
placé devant un tableau, const signifie que ce sont les éléments du tableau
qui ne peuvent être modifiés.
Cette possibilité de préciser qu’un tableau ne peut être modifié est d’autant plus im-
portante qu’un tableau est toujours passé en référence : sans le const, on ne pourrait
assurer cette préservation des valeurs :
void f ( i n t t [ 4 ] ) {
...
}
void g ( c o n s t i n t t [ 4 ] ) {
...
}
void h ( c o n s t i n t ∗ t , i n t n ) {
...
}
...
int a [ 4 ] ;
f (a ); / / m o d i f i e p e u t −ê t r e a [ ]
g(a ) ; / / ne m o d i f i e p a s a [ ]
h ( a , 4 ) ; / / ne m o d i f i e p a s a [ ]
...
186
12. Fonctions et classes paramétrées (templates) 12.7. Fiche de référence

Boucles — if (i==0) j=1; void afficher(int x,
— do { — if (i==0) j=1; int y) {
... else j=2; if (x<0 || y<0)
} while(!ok); return;
if (x>=w || y>=h)
— int i=1; — if (i==0) { return;
while(i<=100) { j=1; DrawPoint(x,y,RED);
... k=2; }
i=i+1; }
} — Appel :
— bool t=(i==0); int f(int a) { ... }
— for(int i=1;i<=10;i++) if (t) int g() { ... }
... j=1; ...
— for(int i=1,j=10;j>i; — switch (i) { int i=f(2),j=g();
i=i+2,j=j-3) case 1: — Références :
... ...; void swap(int& a,
— for (int i=...) ...; int& b){
for (int j=...) { break; int tmp=a;
//saute cas i==j case 2: a=b;b=tmp;
if (i==j) case 3: }
continue; ...; ...
... break; int x=3,y=2;
} default: swap(x,y);
— for (int i=...) { ...;
} — Surcharge :
... int hasard(int n);
if (t[i]==s){ — mx=(x>y)?x:y; int hasard(int a,
// quitte boucle int b);
break; Fonctions
double hasard();
} — Définition :
... int plus(int a,int b){ — Opérateurs :
} int c=a+b; vect operator+(
return c; vect A,vect B) {
Clavier } ...
— Debug : F5 void affiche(int a) { }
cout << a << endl; ...
— Step over : F10 vect C=A+B;
}
— Step inside : F11 — Pile des appels
— Déclaration :
— Indent : Ctrl+A,Ctrl+I int plus(int a,int b); — Itératif/Récursif
— Step out : Maj+F11 — Retour : — Références constantes (pour
— Gest. tâches : Ctrl+Maj+Ech int signe(double x) { un passage rapide) :
Tests if (x<0) void f(const obj& x){
return -1; ...
— Comparaison :
if (x>0) }
== != < > <= >=
return 1; void g(const obj& x){
— Négation : ! return 0; f(x); // OK
— Combinaisons : && || } }
187
12.7. Fiche de référence 12. Fonctions et classes paramétrées (templates)

Valeurs par défaut : — Portée : int f(); // méthode
void f(int a,int b=0); int i; int g(int y);
void g() { // i=j; interdit! };
f(12); // f(12,0); int j=2; int obj::f() {
f(10,2);// f(10,2); i=j; // OK! int i=g(3); // mon g
} if (j>1) { int j=x+i; // mon x
void f(int a,int b) { int k=3; return j;
// ... j=k; // OK! }
} } ...
Inline (appel rapide) : //i=k; interdit! int main() {
inline double — Types : obj a;
sqr(double x) { int i=3; a.x=3;
return x*x; double x=12.3; int i=a.f();
} char c=’A’; — class obj {
... string s="hop"; int x,y;
double y=sqr(z-3); bool t=true; void a_moi();
float y=1.2f; public:
Référence en retour :
unsigned int j=4; int z;
int i; // Var. globale
signed char d=-128; void pour_tous();
int& f() {
unsigned char d=25; void autre(obj A);
return i;
complex<double> };
}
z(2,3); void obj::a_moi() {
...
f()=3; // i=3! x=..; // OK
— Variables globales : ..=y; // OK
Structures int n; z=..; // OK
— struct Point { const int m=12; }
double x,y; void f() { void obj::pour_tous(){
Color c; n=10; // OK x=..; // OK
}; int i=m; // OK a_moi(); // OK
... ... }
Point a; — Conversion : void autre(obj A) {
a.x=2.3; a.y=3.4; int i=int(x),j; x=A.x; // OK
a.c=Red; float x=float(i)/j; A.a_moi(); // OK
Point b={1,2.5,Blue}; }
— Pile/Tas
— Une structure est un objet en- ...
— Type énuméré :
tièrement public (→ cf ob- int main() {
enum Dir{N,E,S,W};
jets !) obj A,B;
void avance(Dir d);
A.x=..; //NON
Variables — Variables statiques : A.z=..; //OK
— Définition : int f() { A.a_moi(); //NON
int i; static bool once=true; A.pour_tous(); //OK
int k,l,m; if (once) { A.autre(B); //OK
— Affectation : once=false;
... — class obj {
i=2; obj operator+(obj B);
j=i; }
... };
k=l=3; ...
}
— Initialisation : int main() {
int n=5,o=n; Objets obj A,B,C;
— Constantes : — struct obj { C=A+B;
const int s=12; int x; // champ // C=A.operator+(B)
188

Méthodes constantes : } — Fonctions : déclarations dans
void obj::f() const{ Constructeur de copie : le .h, définitions dans le
... obj::obj(const obj& o){ .cpp
} ... — Types : définitions dans le .h
void g(const obj& x){ }
x.f(); // OK — Ne déclarer dans le .h que les
Utilisé par : fonctions utiles.
} - obj b(a);
- obj b=a; — #pragma once au début du
Constructeur :
//mieux que obj b;b=a; fichier.
class point {
int x,y; - paramètres des fonctions — Ne pas trop découper. . .
public: - valeur de retour
point(int X,int Y); STL
Affectation :
}; obj& obj::operator=( — min,max,...
point::point(int X, const obj&o){ — complex<double> z;
int Y){ ...
x=X; — pair<int,string> p;
return *this;
y=Y; p.first=2;
}
} p.second="hop";
Objets avec allocation dyna-
... — #include<list>
mique automatique : cf sec-
point a(2,3); using namespace std;
tion 10.11
Constructeur vide : ...
Accesseurs : list<int> l;
obj::obj() {
class mat { l.push_front(1);
...
double *x; ...
}
public:
... — if(l.find(3)!=l.end())
double& operator()
obj a; ...
(int i,int j){
Objets temporaires : assert(i>=0 ...); — list<int>::
vec vec::operator+( return x[i+M*j]; const_iterator it;
vec b) { } for (it=l.begin();
return vec(x+b.x, double operator() it!=l.end();it++)
y+b.y); (int i,int j)const{ s+= *it;
} assert(i>=0 ...); — list<int>::iterator it
... return x[i+M*j]; for (it=l.begin();
c=vec(1,2) } it!=l.end();it++)
+f(vec(2,3)); ... if (*it==2)
Destructeur : Compilation séparée *it=4;
obj::~obj() { — #include "vect.h", aussi — stack, queue, heap,
... dans vect.cpp map, set, vector...
189

Template class hop { stringstream f;
— Fonctions : .. // Chaîne vers entier
// A mettre dans le }; f << s; f >> i;
// fichier qui utilise ... // Entier vers chaîne
// ou dans un .h hop<3> A; f.clear();
template <typename T> ... f << i; f >> s; ⇔
T maxi(T a,T b) { s = std::to_string(i);
Entrées/Sorties
... — ostream& operator<<(
— #include <iostream>
} ostream& f,
using namespace std;
... const point&p){
...
// Le type est trouvé f<<p.x<<’ ’<< p.y;
// tout seul! return f;
cin >> i >> j;
maxi(1,2); //int }
maxi(.2,.3); //double — #include <fstream> istream& operator>>(
maxi("a","c");//string using namespace std; istream& f,point& p){
ofstream f("hop.txt"); f>>p.x>>p.y;
f << 1 << ’ ’ << 2.3; return f;
— Objets :
f.close(); }
template <typename T>
ifstream g("hop.txt");
class paire {
if (!g.is_open()) { Conseils
T x[2];
return 1;
public: — Nettoyer en quittant.
}
paire() {} — Erreurs et warnings : cliquer.
int i;
paire(T a,T b) {
double x; — Indenter.
x[0]=a;x[1]=b;
g >> i >> x;
} — Ne pas laisser de warning.
g.close();
T add()const; — Utiliser le debuggeur.
}; — do {
... ... — Faire des fonctions.
template <typename T> } while (!(g.eof()); — Tableaux : pas pour transcrire
T paire<T>::add()const{ — ofstream f; une formule mathématique !
return x[0]+x[1]; f.open("hop.txt");
} — double x[10],y;
... ofstream f("hop.bin", — Faire des fichiers séparés.
// Le type doit être ios::binary); — Le .h doit suffire à l’utilisa-
// précisé! f.write((const char*)x, teur (qui ne doit pas regarder
paire<int> a(1,2); 10*sizeof(double)); le .cpp)
int s=a.somme(); f.write((const char*)&y,— Ne pas abuser du récursif.
paire<double> b; sizeof(double));
... f.close(); — Ne pas oublier delete.
— Multiples : ifstream g("hop.bin", — Compiler régulièrement.
template <typename T, ios::binary); — #include <cassert>
typename S> g.read((char*)x, ...
class hop { 10*sizeof(double)); assert(x!=0);
... g.read((const char*)&y, y=1/x;
}; sizeof(double));
g.close(); — Faire des objets.
...
hop<int,string> A; — string s; — Ne pas toujours faire des ob-
... ifstream f(s.c_str()); jets !
— Entiers : — #include <sstream> — Penser interface / implémen-
template <int N> using namespace std; tation / utilisation.
190

Divers set(i,1) : i|=(1<<n) — int *t,s;// s est int
reset(i,1) : i&=~(1<<n) // non int*
— i++; test(i,1) : if (i&(1<<n))
i--; t=new int[n];
flip(i,1) : i^=(1<<n) s=new int[n];// NON!
i-=2;
j+=3; — class vec {
Erreurs fréquentes
int x,y;
— j=i%n; // Modulo — Pas de définition de fonction public:
— #include <cstdlib> dans une fonction ! ...
... — int q=r=4; // NON! };
i=rand()%n; ...
— if (i=2) // NON!
x=rand()/ vec a={2,3}; // NON
if i==2 // NON!
double(RAND_MAX); — vec v=vec(1,2);//NON
if (i==2) then // NON!
— #include <ctime> vec v(1,2); // OUI
— for(int i=0,i<100,i++)
// Un seul appel — obj* t=new obj[n];
// NON!
srand((unsigned int) delete t; // manque []
time(0)); — int f() {...}
int i=f; // NON! — //NON!
— #include <cmath> void f(int a=2,int b);
double sqrt(double x); — double x=1/3; // NON!
int i,j; — void f(int a,int b=0);
x=i/j; // NON! void f(int a);// NON!
double acos(double x); x=double(i/j); //NON! — Ne pas tout mettre inline !
— #include <string> — double x[10],y[10]; — int f() {
using namespace std; for(int i=1;i<=10;i++) ...
string s="hop"; y[i]=2 * x[i];//NON }
char c=s[0]; — int n=5; f()=3; // HORREUR!
int l=s.size(); int t[n]; // NON — int& f() {
if (s1==s1) ... int i;
— int f()[4] { // NON!
if (s1!=s2) ... return i;
int t[4];
if (s1<s2) ... }
...
size_t i=s.find(’h’), f()=3; // NON!
return t; // NON!
j=s.find(’h’,3); — if (i>0 & i<n) // NON
}
k=s.find("hop"); if (i<0 | i>n) // NON
int t[4]; t=f();
l=s.find("hop",3);
a="comment"; — int s[3]={1,2,3},t[3]; — if (...) {
b="ça va?"; t=s; // NON! ...
txt=a+" "+b; if (...)
— int t[2];
s1="un deux trois"; break; // Non,
t={1,2}; // NON!
s2=string(s1,3,4); // boucles seulement
— struct Point { }
getline(cin,s);
double x,y;
getline(cin,s,’:’); — for (i ...)
} // NON!
const char *t=s.c_str(); for (j ...) {
— Point a; ...
a={1,2}; // NON! if (...)
s=double(clock())
/CLOCKS_PER_SEC; — #include "tp.cpp"//NON break;//NON, quitte
// juste boucle j
— #include <cmath> — int f(int t[][]);//NON
int t[2,3]; // NON! — int i;
double pi=M_PI;
t[i,j]=...; // NON! double x;
— Opérateurs binaires j=max(i,0);//OK
and : a&b — int* t;
y=max(x,0);//NON!
or : a|b t[1]=...; // NON!
// 0.0 et non 0: max
xor : a^b — int* t=new int[2]; // est un template STL
right shift : a>>n int* s=new int[2];
left shift : a<<n s=t; // On perd s!
complement : ~a delete[] t; Imagine++
exemples : delete[] s;//Déjà fait — Voir documentation. . .
191

Tableaux t[i]=0; — 2D :
— Définition : } int A[2][3];
— void init(int t[], A[i][j]=...;
— double x[5],y[5]; int A[2][3]=
int n) {
for(int i=0;i<5;i++) {{1,2,3},{4,5,6}};
for(int i=0;i<n;i++)
y[i]=2*x[i]; void f(int A[2][2]);
t[i]=0;
— const int n=5; } — 2D dans 1D :
int i[n],j[2*n]; int A[2*3];
— Taille variable :
— Initialisation : A[i+2*j]=...;
int* t=new int[n];
int t[4]={1,2,3,4}; ... — Taille variable (suite) :
string s[2]={"ab","c"}; delete[] t; int *t,*s,n;
— Affectation : — En paramètre (suite) : — En paramètre (fin) :
int s[3]={1,2,3},t[3]; void f(const int* t,
— void f(int* t,int n){ int n) {
t[i]=... ...
t[i]=s[i];
} s+=t[i]; // OK
— En paramètre :
— void alloue(int*& t){ ...
— void init(int t[4]) { t=new int[n]; t[i]=...; // NON!
for(int i=0;i<4;i++) } }
192
A. Travaux Pratiques
Annexe A
Travaux Pratiques
Note : les corrigés seront disponibles sur la page web du cours après chaque TP.
A.1 L’environnement de programmation

A.1.1 Bonjour, Monde !
1. Connexion :
Se connecter sous Windows ou Linux.
2. Projet :
Télécharger l’archive Tp1_Initial.zip depuis la page du cours, la décom-
presser sur le bureau. Le fichier CMakeLists.txt décrit le projet. La ligne qui
nous intéresse de ce fichier texte est la suivante :
a d d _e xe cu ta bl e ( Tp1 Tp1 . cpp )
Elle indique que le programme s’appellera Tp1 (Tp1.exe sous Windows) et que
le code source pour le construire est dans le fichier Tp1.cpp.
QtCreator est l’environnement de programmation que nous utiliserons, il a
l’avantage de fonctionner sur les principales plates-formes (Linux, Windows ou
Mac) et de comprendre nativement Cmake. 1 Pour démarrer, lancez QtCreator
et choisissez “Open Project” pour aller chercher le fichier CMakeLists.txt. Re-
gardez en bas de la fenêtre l’onglet , 2 qui doit afficher tout
un tas de messages : c’est le résultat de la lecture du fichier et la création d’un dos-
sier de “build”, où seront mis tous les fichiers générés par QtCreator. Cela veut
dire aussi que ce dossier n’est pas crucial, car il sera simple à regénérer : quand
on a fini un code, on peut sans problème nettoyer en supprimant ce dossier.
3. Programmation : insérez une ligne de commentaire avec votre nom au début du
fichier Tp1.cpp. Les commentaires sont introduits par // et vont jusqu’à la fin de
la ligne. Ils sont ignorés par le compilateur, mais utiles pour le programmeur. Ra-
joutez ensuite cout << "Hello" << endl; sur la ligne avant return 0; dans le fichier
Tp1.cpp.
1. La plupart des autres environnements, comme Visual Studio (Windows) et Xcode (Mac) ne
connaissent pas Cmake, et on doit utiliser nous-mêmes Cmake pour convertir en un projet natif de
l’environnement.
2. Si vous ne le voyez pas, vous pouvez le faire apparaître avec la petite flèche à droite de ces onglets
A.1. L’environnement de programmation A. Travaux Pratiques
4. Génération : Appuyez sur l’outil marteau en bas à droite pour générer le pro-
gramme. Regardez dans l’onglet 4 “Compile Output”, il vous dit qu’il a créé un
fichier Tp1.cpp.o. Constatez avec un gestionnaire de fichiers que le fichier est
bien dans un sous-dossier du “build”. Observez aussi que le programme Tp1 est
aussi présent.
5. Exécution :
(a) Lancez le programme avec la flèche verte dans QtCreator, observez le ré-
sultat dans l’onglet 3 “Application Output”.
(b) Vérifiez qu’on a en fait créé un programme indépendant qu’on peut lancer
dans une fenêtre de commande :
— Ouvrez un terminal (sous Windows : "Démarrer/Exécuter", lancez
la commande “cmd”)
— Sous Windows, tapez "D:", 3 puis
"cd \Documents and Settings\login\Bureau\build-Tp1...\Tp1"
(apprenez à profiter de la complétion automatique avec la touche TAB).
Sous Linux, le chemin ne sera pas le même, et remplacez les \ par des /.
— Vérifiez la présence de Tp1.exe ou Tp1 avec la commande "dir" (Win-
dows) ou "ls" (Linux).
— Tapez "./Tp1".
6. Compression :
En cliquant à droite sur le répertoire Tp1, fabriquer une archive comprimée Tp1.zip
(ou Tp1.7z suivant la machine). Une telle archive, comprenant tous les fichiers
nécessaires à la compilation, sera le format utilisé pour déposer vos exercices et
rendus de TP sur Educnet.
Notez bien qu’avec Cmake nous avons deux dossiers :
— Le dossier source contenant les fichiers Tp1.cpp et CMakeLists.txt ;
— Le dossier build que vous avez choisi au démarrage de Cmake.
Le plus important est le premier, puisque le deuxième peut toujours être régénéré
avec Cmake. N’envoyez à votre enseignant que le répertoire source, il recompi-
lera lui-même. Votre build lui est probablement inutile car il n’utilise pas le même
système que vous. Ainsi, quand vous avez terminé un projet ou un TP, n’hési-
tez pas à nettoyer en supprimant votre dossier build, mais gardez précieusement
votre dossier source, c’est celui-ci qui représente le résultat de votre travail. Bien
que Cmake autorise d’utiliser un même répertoire pour les deux, c’est à éviter,
pour bien séparer les sources et les fichiers générés automatiquement. Pour com-
prendre un peu comment tous ces outils se coordonnent, on peut se reporter à
l’annexe C du polycopié.
Le dossier précieux représentant votre travail est le dos-

sier source, Tp1_Initial. Celui jetable est le dossier build,
build-Tp1_Initial-....
3. Sur certaines machines, il faut en fait aller sur C :, vérifiez en regardant où est installé votre projet
194
A. Travaux Pratiques A.1. L’environnement de programmation
7. Vérifiez qu’on peut tout recommencer : quittez QtCreator, effacez vos dos-
siers source et build, extrayez le source de votre archive ; s’il reste un fichier
CMakeLists.txt.user, créé par QtCreator, supprimez-le avant de lancer
QtCreator et d’ouvrir le projet.
A.1.2 Premières erreurs

Vous en ferez beaucoup, et c’est tout à fait normal. Autant s’y habituer dès mainte-
nant.
1. Modifier le programme :
Modifier le programme en changeant par exemple la phrase affichée.
(a) Tester une nouvelle génération/exécution. Vérifier que QtCreator sauve

le fichier automatiquement avant de générer.
Lancer directement une exécution sauve et génère automatique-

ment.
Du coup, l’outil marteau peut sembler inutile. Néanmoins, il est bon lors
du codage de vérifier simplement la compilation très fréquemment, sans se
préoccuper de l’exécution car il n’y a encore rien à observer.
2. Erreurs de compilation
Provoquer, constater et apprendre à reconnaître quelques erreurs de compilation :
(a) includ au lieu de include
(b) iostrem au lieu de iostream
(c) Oublier le ; après std
(d) inte au lieu de int
(e) cou au lieu de cout
(f) Oublier les guillemets " fermant la chaîne "Hello ... "
(g) Rajouter une ligne i=3; avant le return.
A ce propos, il est utile de découvrir que :
Double-cliquer sur un message d’erreur (Onglet 1 “Issues”) positionne

l’éditeur sur l’erreur.
Notez que l’onglet 1 n’est qu’un extrait automatique et cliquable de l’onglet 4,

et que le message complet est dans ce dernier. Parfois l’extraction automatique a
des ratés et le message d’erreur de l’onglet 1 n’est pas clair car incomplet.
3. Erreur de linker
Il est un peu tôt pour réussir à mettre le linker en erreur, mais ça arrivera quand
on organisera notre code en plusieurs fichiers. Il est pourtant indispensable de
savoir différencier ses messages de ceux du compilateur. En général, le linker
indiquera une erreur s’il ne trouve pas une fonction ou des variables parce qu’il
manque un fichier objet ou une bibliothèque. C’est aussi une erreur s’il trouve
deux fois la même fonction. . .
195
(a) Rajouter une ligne f(2); avant le return et générer. C’est pour l’instant une
erreur de compilation (il ne sait pas ce que f désigne).
(b) Corriger l’erreur de compilation en rajoutant une ligne (pour l’instant "ma-
gique")
void f ( int i ); avant la ligne avec main. Générer le programme : le linker
constate l’absence d’une fonction f() utilisée par la fonction main() qu’il ne
trouve nulle part.
(c) Effacez maintenant l’appel à f dans main(). Tout remarche à nouveau. Re-
nommez main en main en main2. L’absence de fonction main sera remar-
quée par le linker, qui refusera de générer le programme.
4. Indentations :
Avec toutes ces modifications, le programme ne doit plus être correctement "in-
denté". C’est pourtant essentiel pour une bonne compréhension et repérer d’éven-
tuelle erreur de parenthèses, accolades, etc. Le menu Edit/Advanced fournit de
quoi bien indenter.
Pour repérer des erreurs, toujours bien indenter. Ctrl+I = indenter la
zone sélectionnée. Ctrl+A,Ctrl+I = indenter tout le fichier.
5. Warnings du compilateur
En modifiant le main(), provoquer les warnings suivants : 4
(a) int i ;
i =2.5;
cout << i << endl;
Exécuter pour voir le résultat.
(b) int i ;
i=4;
if ( i=3) cout << "salut" << endl;
Exécuter !
(c) Ajouter exit; comme première instruction de main. Appeler une fonction
en oubliant les arguments arrive souvent ! Exécuter pour voir. Corriger en
mettant exit (0); . (La fonction exit () quitte le programme en urgence !)
Certains warnings sont anodins (faux positifs) et ne sont pas forcément des er-
reurs. Le problème est que ne pas les corriger peut noyer les vrais positifs, il faut
donc s’efforcer de tous les corriger.
Il est très formellement déconseillé de laisser passer des warnings ! Il
faut les corriger au fur et à mesure. Une option du compilateur propose
même de les considérer comme des erreurs !
A.1.3 Debugger
Savoir utiliser le debuggeur est essentiel. Il doit s’agir du premier réflexe en
présence d’un programme incorrect. C’est un véritable moyen d’investiga-
tion, plus simple et plus puissant que de truffer son programme d’instruc-
tions supplémentaires destinées à espionner son déroulement.
4. Aller dans le mode “Projects” de QtCreator , rubrique CMake, clicker sur le bouton “Ad-
vanced” et ajouter “-Wall -Wextra” à la variable CMAKE_CXX_FLAGS.
196
A. Travaux Pratiques A.1. L’environnement de programmation
1. Taper le main suivant.

i n t main ( )
{
int i , j , k ;
i =2;
j =3∗ i ;
i f ( j ==5)
k=3;
else
k=2;
return 0;
}
2. Pour pouvoir utiliser le debuggeur avec QtCreator, il faut compiler en mode
Debug. Le choix du mode se fait en cliquant sur le petit terminal au-dessus

du triangle vert d’exécution. Observez que la variable CMAKE_BUILD_TYPE vaut
alors Debug dans le mode “Projects”.
3. Lancer le programme "sous le debuggeur" avec le triangle vert avec le bug. Le
programme s’exécute mais rien ne semble se passer.
4. Placer un "point d’arrêt" en cliquant dans la colonne de gauche à la hauteur de la
ligne i=2; puis relancer le debuggeur.
5. Avancer en "Step over" avec F10 ou le bouton correspondant et suivre les va-
leurs des variables (dans la fenêtre spéciale ou en plaçant (sans cliquer !) la souris
sur la variable).
6. A tout moment, on peut interrompre l’exécution avec Stop. Arrêter l’exécution
avant d’atteindre la fin de main sous peine de partir dans la fonction qui a appelé
main !
7. Placer un deuxième point d’arrêt et voir que F5 redémarre le programme jus-
qu’au prochain point d’arrêt rencontré.
8. Ajouter i=max(j,k); avant le return. Utiliser "Step into" ou F11 ou le bouton
correspondant quand le curseur est sur cette ligne. Constater la différence avec
F10.
9. Enfin, pour voir à quoi ressemble du code machine, exécuter jusqu’à un point
d’arrêt puis activer le menu Debug/Operate by Instruction. On peut aussi
dans ce même menu voir les registres du micro-processeur. Il arrive qu’on se
retrouve dans la fenêtre "code machine" sans l’avoir demandé quand on debugge
un programme pour lequel on n’a plus le fichier source. Cet affichage est en fait
très utile au programmeur chevronné pour vérifier ce que fait le compilateur et
voir s’il optimise bien.
10. Les registres sont visibles en allant dans le menu Window puis Views. Voir Fi-
gure A.1.
F5 = = Debug
Touches utiles : F10 = = Step over
F11 = = Step inside
197
F IGURE A.1 – QtCreator montrant le code machine et les registres
A.1.4 S’il reste du temps

Téléchargez le programme supplémentaire Tp1_Final.zip sur la page du cours
(http://imagine.enpc.fr/~monasse/Info), jouez avec. . . et complétez-le !
A.1.5 Installer Imagine++ chez soi

Allez voir sur http://imagine.enpc.fr/~monasse/Imagine++. Installez sur
votre ordinateur portable et essayez de refaire ce TP avec QtCreator.
198
A. Travaux Pratiques A.2. Variables, boucles, conditions, fonctions
A.2 Variables, boucles, conditions, fonctions

A.2.1 Premier programme avec fonctions
1. Récupérer le programme exemple :
Télécharger l’archive Tp2.zip sur la page du cours, la décompresser sur le bu-
reau et ouvrir le projet en utilisant le CMakeLists.txt de Tp2_Initial. Étu-
dier le projet Hop dont voici les sources :
3
4 i n t plus ( i n t a , i n t b )
5 {
6 int c ;
7 c=a+b ;
8 return c ;
9 }
10
11 void t r i p l e 1 ( i n t a )
12 {
13 a=a ∗ 3 ;
14 }
15
16 void t r i p l e 2 ( i n t& a )
17 {
18 a=a ∗ 3 ;
19 }
20
21 i n t main ( )
22 {
23 i n t i , j =2 , k ;
24 i =3; Mini tennis. . .
25 k=plus ( i , j ) ;
26 triple1 ( i );
27 triple2 ( i );
28 return 0;
29 }
2. Debugger :
Exécuter le programme pas à pas et étudier la façon dont les variables changent.
Vous devez utiliser le programme compilé en mode Debug.
A.2.2 Premier programme graphique avec Imagine++

Dans ce TP et les suivants, nous utiliserons la librairie graphique d’Imagine++ (cf
annexe du polycopié). Elle permet de gérer très simplement le fenêtrage, le dessin, et
les entrées-sorties clavier et souris.
199
A.2. Variables, boucles, conditions, fonctions A. Travaux Pratiques
1. Programme de départ :
Etudier le programme du projet Tennis dont voici le source :
3 ...
4
5 // / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
7 i n t main ( )
8 {
10 openWindow ( 2 5 6 , 2 5 6 ) ;
11 / / P o s i t i o n e t v i t e s s e de l a b a l l e
12 i n t xb =128 ,
13 yb =20 ,
14 ub =2 ,
15 vb = 3 ;
18 / / A f f i c h a g e de l a b a l l e
19 f i l l R e c t ( xb −3 ,yb − 3 , 7 , 7 , Red ) ;
20 / / Temporisation
21 milliSleep (20);
22 / / E f f a c e m e n t de l a b a l l e
23 f i l l R e c t ( xb −3 ,yb − 3 , 7 , 7 , White ) ;
24 / / Rebond
25 i f ( xb+ub >253)
26 ub=−ub ;
27 / / Mise a j o u r d e l a p o s i t i o n d e l a b a l l e
28 xb+=ub ;
29 yb+=vb ;
30 }
32 return 0;
33 }
Ne pas s’intéresser à la fonction Clavier()
Générer puis exécuter la solution. Que se passe-t-il ?

2. Aide en ligne A tout moment, la touche F1 permet d’accéder à la documentation
du mot clé situé sous le curseur. Tester cette fonctionnalité sur les mots-clés if ,
while et return.
Touche utile : F1 = Accéder à la documentation
3. Comprendre le fonctionnement du programme :

Identifier la boucle principale du programme. Elle se décompose ainsi :
200
A. Travaux Pratiques A.2. Variables, boucles, conditions, fonctions
(a) Affichage de la balle

(b) Temporisation de quelques millisecondes pour que la balle ne se déplace pas
trop vite
(c) Effacement de la balle
(d) Gestion des rebonds
(e) Mise à jour des coordonnées de la balle
Pourquoi la ligne comportant l’instruction while suscite-t-elle un warning ? A
quoi sert la condition formulée par l’instruction if ?
4. Gestion de tous les rebonds :
Compléter le programme afin de gérer tous les rebonds. Par exemple, il faut in-
verser la vitesse horizontale ub quand la balle va toucher les bords gauche ou
droit de la fenêtre.
5. Variables globales :
Doubler la hauteur de la fenêtre. Modifier la taille de la balle. Cela nécessite de
modifier le code à plusieurs endroits. Aussi, à la place de valeurs numériques
“en dur”, il vaut mieux définir des variables. Afin de simplifier et bien que ça ne
soit pas toujours conseillé, utiliser des variables globales constantes. Pour cela,
insérer tout de suite après les deux lignes d’include le code suivant
c o n s t i n t width = 2 5 6 ; / / Largeur de l a f e n e t r e
const i n t height = 256; / / Hauteur d e l a f e n e t r e
c o n s t i n t b a l l _ s i z e = 3 ; / / Rayon d e l a b a l l e
et reformuler les valeurs numériques du programmes à l’aide de ces variables.
Le mot clé const indique que ces variables ne peuvent être modifiées après leur
initialisation. Essayer de rajouter la ligne width=300; au début de la fonction main
et constater que cela provoque une erreur de compilation.
6. Utilisation de fonctions :
La balle est dessinée deux fois au cours de la boucle, la première fois en rouge
et la deuxième fois en blanc pour l’effacer. Ici le dessin de la balle ne nécessite
qu’une ligne mais cela pourrait être beaucoup plus si sa forme était plus com-
plexe. Aussi, pour que le programme soit mieux structuré et plus lisible, et que
le code comporte le moins possible de duplications, regrouper l’affichage de la
balle et son effacement dans une fonction DessineBalle définie avant la fonction
main :
void D e s s i n e B a l l e ( i n t x , i n t y , Color c o l ) {
...
}
De même, définir une fonction
void BougeBalle(int &x,int &y,int &u,int &v)
pour gérer les rebonds et le déplacement de la balle.
A.2.3 Jeu de Tennis

Nous allons rendre ce programme plus ludique en y ajoutant deux raquettes se
déplaçant horizontalement en haut et en bas de l’écran, et commandées par les touches
du clavier.
201
A.2. Variables, boucles, conditions, fonctions A. Travaux Pratiques
1. Affichage des raquettes :

Ajouter dans la fonction main des variables xr1,yr1,xr2,yr2 dédiées à la position
des deux raquettes. Puis définir une fonction DessineRaquette en prenant modèle
sur DessineBalle. Placer les appels de ces fonctions aux endroits appropriés dans
la boucle principale.
2. Gestion du clavier :
La gestion du clavier est réalisée pour vous par la fonction Clavier dont nous
ignorerons le contenu pour l’instant. Cette fonction nous permet de savoir direc-
tement si une des touches qui nous intéressent (q et s pour le déplacement de la
première raquette, k et l pour la deuxième) sont enfoncées ou non. Cette fonc-
tion, Clavier(int& sens1, int& sens2), retourne dans sens1 et sens2, les valeurs 0,
-1 ou 1 (0 : pas de déplacement, -1 : vers la gauche, 1 : vers la droite).
3. Déplacement des raquettes :
Coder le déplacement d’une raquette dans une fonction
void BougeRaquette(int &x, int sens)
puis appeler cette fonction dans la boucle principale pour chacune des deux ra-
quettes. Evidemment, faire en sorte que les raquettes ne puissent sortir de la fe-
nêtre.
4. Rebonds sur les raquettes :
S’inspirer de la gestion des rebonds de la balle. Ici il faut non seulement vérifier si
la balle va atteindre le bas ou le haut de l’écran mais aussi si elle est assez proche
en abscisse de la raquette correspondante.
5. Comptage et affichage du score :
Modifier la fonction BougeBalle afin de comptabiliser le score des deux joueurs
et l’afficher dans la console.
6. Pour ceux qui ont fini :
Lors d’un rebond sur la raquette, modifier l’inclinaison de la trajectoire de la balle
en fonction de la vitesse de la raquette ou de l’endroit de frappe.
Vous devriez avoir obtenu un programme ressemblant à celui de la figure.
202
A. Travaux Pratiques A.3. Tableaux
Master mind à la console. . . Master mind gra-

phique. . .
F IGURE A.2 – Les deux incarnations de notre jeu.
A.3 Tableaux
Dans ce TP, nous allons programmer un jeu de Mastermind, où l’utilisateur doit
deviner une combinaison générée aléatoirement par l’ordinateur. Le joueur dispose
d’un nombre déterminé d’essais. A chaque essai d’une combinaison, l’ordinateur four-
nit deux indices : le nombre de pions correctement placés et le nombre de pions de la
bonne couleur mais incorrectement positionnés.
A.3.1 Mastermind Texte

1. Récupérer la solution de départ :
Télécharger l’archive Tp3_Initial.zip sur la page du cours, la décompresser
dans un répertoire faisant apparaître les noms des deux élèves (en cas de binôme)
et ouvrir le projet MasterMind. Etudier ce projet.
2. Représenter une combinaison :
Nous prendrons ici une combinaison de 5 pions de 4 couleurs différentes. La
couleur d’un pion sera représentée par un entier compris entre 0 et 3. Pour une
combinaison de 5 pions, nous allons donc utiliser un tableau de 5 entiers.
i n t combin [ 5 ] ; / / t a b l e a u d e 5 e n t i e r s
3. Afficher une combinaison :

Programmer une fonction permettant d’afficher une combinaison donnée à l’écran.
La manière la plus simple de faire consistera à faire afficher les différents chiffres
de la combinaison sur une même ligne les uns à la suite des autres.
4. Générer une combinaison aléatoirement :
En début de partie, l’ordinateur doit générer aléatoirement une combinaison à
faire deviner à l’utilisateur. Nous allons pour cela utiliser les fonctions déclarées
dans le fichier cstdlib , notamment la fonction rand() permettant de générer un
203
A.3. Tableaux A. Travaux Pratiques
nombre au hasard entre 0 et RAND_MAX. Afin d’obtenir un nombre entre 0 et n,

on procédera de la manière suivante :
x = rand ()%n ;
Pour que la séquence de nombres générée ne soit pas la même d’une fois sur
l’autre, il est nécessaire d’initialiser le générateur avec une graine variable. La
manière la plus simple de procéder consiste à utiliser l’heure courante. La fonc-
tion time() déclarée dans le fichier ctime permet de l’obtenir.
En fin de compte, la fonction suivante nous permet donc de générer une combi-
naison :
# include <cstdlib >
# i n c l u d e <ctime >
void genereCombinaison ( i n t combin [ 5 ] ) {

f o r ( i n t i = 0 ; i < 5 ; ++ i )
combin [ i ] = rand ( ) % 4 ; / / a p p e l s au g e n e r a t e u r
}
srand ( ( unsigned i n t ) time ( 0 ) ) ; / / i n i t i a l i s a t i o n
genereCombinaison ( combin ) ;
5. Changer la complexité du jeu :

Rapidement, vous allez devenir des experts en Mastermind. Vous allez alors vou-
loir augmenter la difficulté. Il suffira alors d’allonger la longueur de la combinai-
son, ou d’augmenter le nombre de couleurs possibles. Cela vous est d’ores et déjà
très facile si vous avez pensé à définir une constante globale pour chacune de ces
deux grandeurs. Si ce n’est pas le cas, il est grand temps de le faire. Définissez
par exemple :
c o n s t i n t nbcases = 5 ; / / longueur de l a combinaison
c o n s t i n t nbcoul = 4 ; / / nombre d e c o u l e u r s d i f f é r e n t e s
Reprenez le code que vous avez déjà écrit en utilisant ces constantes. Il est très
important de stocker les paramètres constants dans des variables, cela fait gagner
beaucoup de temps lorsque l’on veut les modifier.
6. Saisie d’une combinaison au clavier :
La fonction suivante, que nous vous demanderons d’admettre, saisit une chaîne
de caractères (string) au clavier et remplit le tableau combi[] avec les chiffres que
les nbcases premiers caractères de la chaîne représentent.
void getCombinaison ( i n t combi [ nbcases ] )
{
cout << " Votre e s s a i : " ;
string s ;
c i n >> s ;
f o r ( i n t i = 0 ; i <nbcases ; i ++)
combi [ i ]= s [ i ]− ’ 0 ’ ;
}
204
A. Travaux Pratiques A.3. Tableaux
Attention, le cin ne fonctionne pas depuis le terminal intégré de QtCreator (d’ailleurs

la fenêtre s’appelle Application Output, ne supporte pas l’Input), il faut lui dire
d’utiliser un terminal externe. Aller dans l’onglet Projects, rubrique Run et cli-
quer le bouton “Run in Terminal”.
Dans le cadre de notre Mastermind, il s’agit de modifier cette fonction pour
qu’elle contrôle que la chaîne rentrée est bien de bonne taille et que les chiffres
sont bien entre 0 et nbcoul−1. L’essai devra être redemandé jusqu’à ce que la
combinaison soit valide. On utilisera entre autres la fonction s . size () qui re-
tourne la taille de la chaîne s (la syntaxe de cette fonction sera comprise plus
tard dans le cours. . . )
Une petite explication sur s[ i]−’0’. Les caractères (type char) sont en fait une
valeur numérique, le code ASCII. ’0’ donne le code ASCII du caractère zéro. On
peut le vérifier en faisant par exemple
cout << ( i n t ) ’ 0 ’ << endl ;
(Il faut convertir en entier, sinon on lui demande d’afficher un char, et donc il
affiche le caractère associé au code ASCII, 0 !) Cette valeur est 48. Il se trouve que
les chiffres de 0 à 9 ont des codes ASCII consécutifs : ’0’=48, ’1’=49, ’9’=57. Le type
string de la variable s se comporte comme un tableau de char. Ainsi s[ i]−’0’ vaut
0 si s[ i ] est le caractère 0, ’1’-’0’=1 si c’est le caractère 1, etc.
7. Traitement d’une combinaison :
Il faudrait maintenant programmer une fonction comparant une combinaison
donnée avec la combinaison à trouver. Cette fonction devrait renvoyer deux va-
leurs : le nombre de pions de la bonne valeur bien placés, puis, dans les pions
restant, le nombre de pions de la bonne valeur mais mal placés.
Par exemple, si la combinaison à trouver est 02113 :
00000 : 1 pion bien placé (0xxxx), 0 pion mal placé (xxxxx)
20000 : 0 pion bien placé (xxxxx), 2 pions mal placés (20xxx)
13133 : 2 pions bien placés (xx1x3), 1 pion mal placé (1xxxx)
13113 : 3 pions bien placés (xx113), 0 pion mal placé (xxxxx)
12113 : 4 pions bien placés (x2113), 0 pion mal placé (xxxxx)
...
Pour commencer et pouvoir tout de suite tester le jeu, programmer une fonction
renvoyant uniquement le nombre de pions bien placés.
8. Boucle de jeu : Nous avons maintenant à notre disposition toutes les briques né-
cessaires 5 , il n’y a plus qu’à les assembler pour former un jeu de mastermind.
Pensez par ailleurs à ajouter la détection de la victoire (quand tous les pions sont
bien placés), et celle de la défaite (quand un nombre limite d’essais a été dépassé).
9. Version complète : Compléter la fonction de traitement d’une combinaison pour
qu’elle renvoie également le nombre de pions mal placés.
A.3.2 Mastermind Graphique

Le jeu de Mastermind que nous venons de réaliser reste malgré tout très peu convi-
vial. Nous allons y remédier en y ajoutant une interface graphique.
5. même si la fonction de traitement d’une combinaison est pour l’instant incomplète
205
A.3. Tableaux A. Travaux Pratiques
1. Etude du projet de départ :

Passer dans le projet MastermindGraphique 6
Les fonctions graphiques sont déjà définies. Elles fonctionnent selon un principe
de division de la fenêtre graphique en lignes. La fonction :
void a f f i c h e C o m b i n a i s o n ( i n t combi [ nbcases ] , i n t n ) ;
permet d’afficher la combinaison combi sur la ligne n. Au début du programme,
on laisse en haut de la fenêtre graphique autant de lignes libres que le joueur a
d’essais pour y afficher le déroulement du jeu. On affiche en bas de la fenêtre
graphique un mini mode d’emploi qui résume les correspondances entre touches
et couleurs.
2. Mastermind graphique :
Réinsérer dans ce projet les fonctions de génération aléatoire d’une combinaison
et de comparaison de deux comparaisons écrites précédemment. Puis reprogram-
mer la boucle principale du jeu en utilisant l’affichage graphique.
3. Ultime amélioration :
On souhaite pouvoir effacer une couleur après l’avoir tapée, au cas où l’on se se-
rait trompé. Etudier les fonctions
int Clavier (); et void getCombinaison(int[],int);
La première prend déjà en compte la touche Retour arrière, mais pas la seconde
qui la considère comme une erreur de frappe. Modifier cette dernière en consé-
quence.
6. Sous QtCreator, sélectionnez-le avec l’icône représentant un écran sur la gauche de la fenêtre.
206
A. Travaux Pratiques A.4. Structures
A.4 Structures
Avertissement : Dans ce TP, nous allons faire évoluer des corps soumis à la gravita-
tion, puis leur faire subir des chocs élastiques. Il s’agit d’un long TP qui nous occupera
plusieurs séances. En fait, le TP suivant sera une réorganisation de celui-ci. Les sec-
tions 11 et 15 ne sont données que pour les élèves les plus à l’aise et ne seront abordées
qu’en deuxième semaine. En section A.4.2 sont décrites quelques-unes des fonctions à
utiliser, et en A.4.3 leur justification physique.
A.4.1 Etapes
Mouvement de translation
1. Pour commencer, étudier le projet :
Télécharger le fichier Tp4_Initial.zip sur la page habituelle, le décompresser
et lancer QtCreator. Parcourir le projet, en s’attardant sur les variables globales
et la fonction main (inutile de regarder le contenu des fonctions déjà définies
mais non utilisées). Le programme fait évoluer un point (x, y) selon un mouve-
ment de translation constante (vx, vy), et affiche régulièrement un disque centré
en ce point. Pour ce faire, afin de l’effacer, on retient la position du disque au
dernier affichage (dans ox et oy) ; par ailleurs, deux instructions commençant
par noRefresh sont placées autour des instructions graphiques afin de fluidi-
fier l’affichage.
2. Utiliser une structure :
Modifier le programme de façon à utiliser une structure Balle renfermant toute
l’information sur le disque (position, vitesse, rayon, couleur).
3. Fonctions d’affichage :
Créer (et utiliser) une fonction void AfficheBalle(Balle D) affichant le disque D,
et une autre
void EffaceBalle(Balle D) l’effaçant.
4. Faire bouger proprement le disque :
Pour faire évoluer la position du disque, remplacer les instructions correspon-
dantes déjà présentes dans main par un appel à une fonction qui modifie les
coordonnées d’une Balle, en leur ajoutant la vitesse de la Balle multipliée par
un certain pas de temps défini en variable globale (dt = 1 pour l’instant).
Gravitation
5. Évolution par accélération :

Créer (et utiliser) une fonction qui modifie la vitesse d’une Balle de façon à lui
faire subir une attraction constante ax = 0 et ay = 0.0005. Indice : procéder comme
précédemment, c’est-à-dire ajouter 0.0005 ∗ dt à vy . . .
6. Ajouter un soleil :
On souhaite ne plus avoir une gravité uniforme. Ajouter un champ décrivant la
masse à la structure Balle. Créer un soleil (de type Balle), jaune, fixe (ie de
vitesse nulle) au milieu de la fenêtre, de masse 10 et de rayon 4 pixels (la masse
de la planète qui bouge étant de 1). L’afficher.
207
A.4. Structures A. Travaux Pratiques
7. Accélération gravitationnelle :
Créer (et utiliser à la place de la gravitation uniforme) une fonction qui prend en
argument la planète et le soleil, et qui fait évoluer la position de la planète. Rappel
de physique : l’accélération à prendre en compte est −G mS /r3 → −
r , avec ici G = 1
(Vous aurez sans doute besoin de la fonction double sqrt(double x), qui retourne
la racine carrée de x). Ne pas oublier le facteur dt. . . Faire tourner et observer.
Essayez diverses initialisations de la planète (par exemple x = largeur/2, y =
hauteur/3, vx = 1 , vy = 0). Notez que l’expression de l’accélération devient
très grande lorsque r s’approche de 0 ; on prendra donc garde à ne pas utiliser ce
terme lorsque r devient trop petit.
8. Initialisation aléatoire :
Créer (et utiliser à la place des conditions initiales données pour le soleil) une
fonction initialisant une Balle, sa position étant dans la fenêtre, sa vitesse nulle,
son rayon entre 5 et 15, et sa masse valant le rayon divisé par 20. Vous aurez
probablement besoin de la fonction Random. . .
9. Des soleils par milliers. . .
Placer 10 soleils aléatoirement (et en tenir compte à l’affichage, dans le calcul du
déplacement de l’astéroïde. . . ).
10. Diminuer le pas de temps de calcul :
Afin d’éviter les erreurs dues à la discrétisation du temps, diminuer le pas de
temps dt, pour le fixer à 0.01 (voire à 0.001 si la machine est assez puissante).
Régler la fréquence d’affichage en conséquence (inversement proportionnelle à
dt). Lancer plusieurs fois le programme.
Chocs élastiques simples
11. Faire rebondir l’astéroïde :

Faire subir des chocs élastiques à l’astéroïde à chaque fois qu’il s’approche trop
d’un soleil, de façon à ce qu’il ne rentre plus dedans (fonction ChocSimple),
et rétablir dt à une valeur plus élevée, par exemple 0.1 (modifier la fréquence
d’affichage en conséquent). Pour savoir si deux corps sont sur le point d’entrer
en collision, utiliser la fonction Collision. Ne modifiez pas les fonctions Choc,
ChocSimple et Collision fournies. Par contre, vous en créez de nouvelles pre-
nant en argument Balle (avec le même nom, c’est autorisé du moment que les
arguments des fonctions sont différents, cela s’appelle la surcharge), et elles ap-
pellent la fonction élémentaire adéquate.
Jeu de tir
(figure A.3 droite)
12. Ouvrir un nouveau projet :
Afin de partir dans deux voies différentes et travailler proprement, nous allons
ajouter un nouveau projet Imagine++, appelé Duel, dans cette même solution.
Recopier (par exemple par copier/coller) intégralement le contenu du fichier
Tp4.cpp dans un fichier Duel.cpp. Une fois cette copie faite, modifier le fichier
CMakeLists.txt en ajoutant deux lignes indiquant que l’exécutable Duel dé-
pend de Duel.cpp et utilise la bibliothèque Graphics d’Imagine++.
208
F IGURE A.3 – Corps célestes et jeu de tir. . .
13. À vous de jouer !

Transformer le projet Duel, à l’aide des fonctions qui y sont déjà présentes, en un
jeu de tir, à deux joueurs. Chacun des deux joueurs a une position fixée, et divers
soleils sont placés aléatoirement dans l’écran. Chaque joueur, à tour de rôle, peut
lancer une Balle avec la vitesse initiale de son choix, la balle subissant les effets
de gravitation des divers soleils, et disparaissant au bout de 250 pas de temps
d’affichage. Le gagnant est le premier qui réussit à atteindre l’autre. . . Conseils
pratiques : positionner symétriquement les joueurs par rapport au centre, de pré-
férence à mi-hauteur en laissant une marge d’un huitième de la largeur sur le
côté ; utiliser la fonction GetMouse pour connaître la position de la souris ; en dé-
duire la vitesse désirée par le joueur en retranchant à ces coordonnées celles du
centre de la boule à lancer, et en multipliant par un facteur 0.00025.
14. Améliorations :
Faire en sorte qu’il y ait systématiquement un gros soleil au centre de l’écran (de
masse non nécessairement conséquente) afin d’empêcher les tirs directs.
15. Initialisation correcte :
Modifier la fonction de placement des soleils de façon à ce que les soleils ne s’in-
tersectent pas initialement, et qu’ils soient à une distance minimale de 100 pixels
des emplacements des joueurs.
Chocs élastiques
(figure A.3 gauche)
16. Tout faire évoluer, tout faire rebondir :
On retourne dans le projet Gravitation. Tout faire bouger, y compris les soleils.
Utiliser, pour les chocs élastiques, la fonction Chocs (qui fait rebondir les deux
corps). Faire en sorte que lors de l’initialisation les soleils ne s’intersectent pas.
A.4.2 Aide
Fonctions fournies :
209
A.4. Structures A. Travaux Pratiques
void InitRandom ( ) ;
est à exécuter une fois avant le premier appel à Random.
double Random ( double a , double b ) ;
renvoie un double aléatoirement entre a et b (compris). Exécuter une fois InitRandom();
avant la première utilisation de cette fonction.
void ChocSimple ( double x , double y , double &vx , double &vy , double m,
double x2 , double y2 , double vx2 , double vy2 ) ;
fait rebondir la première particule, de coordonnées (x, y), de vitesse (vx, vy) et de
masse m, sur la deuxième, de coordonnées (x2, y2) et de vitesse (vx2, vy2), sans dé-
placer la deuxième.
void Choc ( double x , double y , double &vx , double &vy , double m,
double x2 , double y2 , double &vx2 , double &vy2 , double m2 ) ;
fait rebondir les deux particules l’une contre l’autre.
bool C o l l i s i o n ( double x1 , double y1 , double vx1 , double vy1 , double r1 ,
double x2 , double y2 , double vx2 , double vy2 , double r 2 ) ;
renvoie true si le corps de coordonnées (x1, y1), de vitesse (vx1, vy1) et de rayon r1
est sur le point d’entrer en collision avec le corps de coordonnées (x2, y2), de vitesse
(vx2, vy2) et de rayon r2, et false sinon.
A.4.3 Théorie physique

NB : Cette section n’est donnée que pour expliquer le contenu des fonctions pré-
programmées fournies avec l’énoncé. Elle peut être ignorée en première lecture.
Accélération
La somme des forces exercées sur un corps A est égale au produit de sa masse par
l’accélération de son centre de gravité.
X→ −
F i/A = mA →
−
a G(A)
i
Gravitation universelle
Soient deux corps A et B. Alors A subit une force d’attraction
→
− 1 −
F B/A = −GmA mB 2 → u B→A .
dA,B
Chocs élastiques
Soient A et B deux particules rentrant en collision. Connaissant tous les paramètres
avant le choc, comment déterminer leur valeur après ? En fait, seule la vitesse des par-
ticules reste à calculer, puisque dans l’instant du choc, les positions ne changent pas.
Durant un choc dit élastique, trois quantités sont conservées :
210
→
−
1. la quantité de mouvement P = mA →
−
v A + mB →
−
vB
2. le moment cinétique M = mA →
−rA×→ −v A + mB →
−
rB×→
−
v B (qui est un réel dans le
cas d’un mouvement plan).
3. l’énergie cinétique Ec = 21 mA vA2 + 12 mB vB2 .
Ce qui fait 4 équations pour 4 inconnues.
Résolution du choc
On se place dans le référentiel du centre de masse. On a alors, à tout instant :
→
−
1. P = 0 (par définition de ce référentiel), d’où mA →
−
v A = −mB → −
v B.
2. M = ( r A − r B ) × mA v A , d’où, en notant ∆ r = r A − r B , M = ∆→
→
− →
− →
− →
− →
− →
− −r × mA →
−
v A.
mA
3. 2Ec = mA (1 + mB
)vA2 .
La constance de Ec nous informe que dans ce repère, la norme des vitesses est
conservée, et la constance du moment cinétique que les vitesses varient parallèlement
à ∆→−r . Si l’on veut que les vitesses varient effectivement, il ne nous reste plus qu’une
possibilité : mutliplier par −1 la composante des → −v i selon ∆→
−
r . Ce qui fournit un algo-
rithme simple de rebond.
Décider de l’imminence d’un choc

On ne peut pas se contenter, lors de l’évolution pas à pas des coordonnées des
disques, de décider qu’un choc aura lieu entre t et t + dt rien qu’en estimant la distance
entre les deux disques candidats à la collision à l’instant t, ni même en prenant en plus
en considération cette distance à l’instant t + dt, car, si la vitesse est trop élevée, un
disque peut déjà avoir traversé l’autre et en être ressorti en t + dt. . . La solution consiste
à expliciter le minimum de la distance entre les disques en fonction du temps, variant
entre t et t + dt.
Soit N (u) = (→ −
r A (u) − →
−
r B (u))2 le carré de la distance en question. On a :
N (u) = (→
−
r A (t) − →
−
r B (t) + (u − t)(→
−
v A (t) − →
−
v B (t)))2
Ce qui donne, avec des notations supplémentaires :
N (u) = ∆→
−
r (t)2 + 2(u − t)∆→
−
r (t) · ∆→
−
v (t) + (u − t)2 ∆→
−
v (t)2
La norme, toujours positive, est minimale au point u tel que ∂u N (u) = 0, soit :
∆→
−
r (t) · ∆→
−
v (t)
(tm − t) = − →
−
∆ v (t)2
Donc :
1. si tm < t, le minimum est atteint en t,
2. si t < tm < t + dt, le minimum est atteint en tm ;
3. sinon, t + dt < tm , le minimum est atteint en t + dt.
Ce qui nous donne explicitement et simplement la plus petite distance atteinte entre
les deux corps entre t et t + dt.
211
A.5. Fichiers séparés A. Travaux Pratiques
A.5 Fichiers séparés

Nous allons poursuivre dans ce TP les simulations de gravitation et de chocs élas-
tiques entamées la semaine dernière, en séparant dans différents fichiers les différentes
fonctions et structures utilisées.
1. De bonnes bases :
Reprenez le travail en cours de la semaine derniére. Si vous avez été au bout
de celui-ci ou au moins jusqu’à la question 7 incluse, faites-en une sauvegarde
séparée pour pouvoir vous y reporter si les travaux entrepris dans ce TP ont
tendance à tout casser.
A.5.1 Fonctions outils

2. Un fichier de définitions. . .
Ajouter un nouveau fichier source nommé tools.cpp au projet. Y placer les
fonctions fournies à l’avance au début du TP4 (InitRandom, Random, Choc, ChocSimple
et Collision), en les retirant de Gravitation.cpp. Ne pas oublier les lignes sui-
vantes, que l’on pourra retirer de Gravitation.cpp :
# include <cstdlib >
# i n c l u d e <ctime >
Attention de ne pas placer le nouveau fichier dans le "build directory" de CMake.
Vous devez bien placer ce fichier dans le dossier des sources (le même que Gra-
vitation.cpp). N’oubliez pas de modifier les arguments de add_executable
du CMakeLists.txt pour y ajouter tools.cpp. QtCreator devrait noter le
changement quand vous sauvez le fichier et relancer Cmake, comme vous de-
vriez le constater dans l’onglet “General Messages”. Si ce n’est pas le cas, relancez
Cmake par le menu.
3. . . . et un fichier de déclarations
Ajouter un nouveau fichier d’en-tête nommé tools.h. Inclure la protection contre
la double inclusion vue en cours (#pragma once). Y placer les déclarations des
fonctions mises dans tools.cpp, ainsi que la définition de dt, en retirant celle-
ci de main. Rajouter au début de tools.cpp et de Gravitation.cpp un
# include " tools . h"
A.5.2 Vecteurs
4. Structure Vector :
Créer dans un nouveau fichier vector.h une structure représentant un vecteur
du plan, avec deux membres de type double. Ne pas oublier le mécanisme de
protection contre la double inclusion. Déclarer (et non définir) les opérateurs et
fonction suivants :
Vector o p e r a t o r +( Vector a , Vector b ) ; / / Somme
Vector o p e r a t o r −( Vector a , Vector b ) ; // Différence
212
A. Travaux Pratiques A.5. Fichiers séparés
double norme2 ( Vector a ) ; / / Norme e u c l i d i e n n e

Vector o p e r a t o r ∗ ( Vector a , double lambda ) ; / / Mult . s c a l a i r e
Vector o p e r a t o r ∗ ( double lambda , Vector a ) ; / / Mult . s c a l a i r e
5. Fonctions et opérateurs sur les Vector :

Créer un nouveau fichier vector.cpp. Mettre un #include du fichier d’en-tête
correspondant et définir les opérateurs qui y sont déclarés (Rappel : sqrt est
défini dans le fichier d’en-tête système <cmath> ; ne pas oublier non plus le
using namespace std; qui permet d’utiliser cette fonction). Astuce : une fois qu’une
version de operator∗ est définie, la deuxième version peut utiliser la première
dans sa définition. . .
6. Vecteur vitesse et vecteur position :
Systématiquement remplacer dans Gravitation.cpp les vitesses et positions
par des objets de type Vector (y compris dans la définition de la structure Balle).
Utiliser autant que possible les opérateurs et fonction définis dans vector.cpp.
A.5.3 Balle à part

7. Structure Balle :
Déplacer la structure Balle dans un nouveau fichier d’en-tête Balle.h. Puisque
Balle utilise les types Vector et Color, il faut aussi ajouter ces lignes :
# i n c l u d e <Imagine/Graphics . h>
using namespace Imagine ;
# include " vector . h"
8. Fonctions associées :
Déplacer toutes les fonctions annexes prenant des Balle en paramètres dans un
nouveau fichier Balle.cpp. Il ne devrait plus rester dans Gravitation.cpp
d’autre fonction que main. Déclarer dans Balle.h les fonctions définies dans
Balle.cpp. Ajouter les #include nécessaires dans ce dernier fichier et dans Gravitation.cp
et faire les adaptations nécessaires (par exemple, si des fonctions utilisent largeur
ou hauteur, comme ces constantes ne sont définies que dans Gravitation.cpp,
il faut les passer en argument. . . )
A.5.4 Retour à la physique

9. Des soleils par milliers. . . :
Placer 10 soleils aléatoirement (et en tenir compte à l’affichage, dans le calcul du
déplacement de l’astéroïde. . . ).
10. Diminuer le pas de temps de calcul :
Afin d’éviter les erreurs dues à la discrétisation du temps, diminuer le pas de
temps dt, pour le fixer à 0.01 (voire à 0.001 si la machine est assez puissante).
Régler la fréquence d’affichage en conséquence (inversement proportionnelle à
dt). Lancer plusieurs fois le programme.
213
A.5. Fichiers séparés A. Travaux Pratiques
Chocs élastiques simples
11. Faire rebondir l’astéroïde :

Faire subir des chocs élastiques à l’astéroïde à chaque fois qu’il s’approche trop
d’un soleil, de façon à ce qu’il ne rentre plus dedans (fonction ChocSimple),
et rétablir dt à une valeur plus élevée, par exemple 0.1 (modifier la fréquence
d’affichage en conséquent). Pour savoir si deux corps sont sur le point d’entrer
en collision, utiliser la fonction Collision.
Jeu de tir
12. Ouvrir un nouveau projet :

Afin de partir dans deux voies différentes et travailler proprement, ajouter un
nouveau projet appelé Duel, dans cette même solution. On ajoute un dossier
Duel au même niveau que Gravitation et on modifie le CMakeLists.txt.
13. Ne pas refaire deux fois le travail : Comme nous aurons besoins des mêmes fonctions
dans ce projet que dans le projet Gravitation, ajouter au projet (sans en créer de
nouveaux !) les fichiers vector.h, vector.cpp, Balle.h, Balle.cpp, tools.h,
tools.cpp. Les fichiers sont les mêmes que dans le projet Gravitation, ils ne sont
pas recopiés. Mettre au début de Duel.cpp (fichier à placer dans le répertoire
Duel) les #include correspondants. Essayer de compiler Duel.cpp. Comme le
compilateur n’arrive pas à trouver les fichiers inclus, qui ne sont pas dans le
même répertoire, il faut lui indiquer où les trouver :
# include " . . / Gravitation/tools . h"
Pour le CMakeLists.txt du répertoire Duel, inspirez-vous de celui de Gravi-

tation.
14. À vous de jouer !
Transformer le projet Duel, à l’aide des fonctions définies auparavant, en un jeu
de tir, à deux joueurs. Chacun des deux joueurs a une position fixée, et divers
soleils sont placés aléatoirement dans l’écran. Chaque joueur, à tour de rôle, peut
lancer une Balle avec la vitesse initiale de son choix, la balle subissant les effets
de gravitation des divers soleils, et disparaissant au bout de 250 pas de temps
d’affichage. Le gagnant est le premier qui réussit à atteindre l’autre. . . Conseils
pratiques : positionner symétriquement les joueurs par rapport au centre, de pré-
férence à mi-hauteur en laissant une marge d’un huitième de la largeur sur le
côté ; utiliser la fonction GetMouse pour connaître la position de la souris ; en
déduire la vitesse désirée par le joueur en retranchant à ces coordonnées celles
du centre de la boule à lancer, et en multipliant par un facteur 0.00025.
15. Améliorations :
Faire en sorte qu’il y ait systématiquement un gros soleil au centre de l’écran (de
masse non nécessairement conséquente) afin d’empêcher les tirs directs.
16. Initialisation correcte :
Modifier la fonction de placement des soleils de façon à ce que les soleils ne s’in-
tersectent pas initialement, et qu’ils soient à une distance minimale de 100 pixels
des emplacements des joueurs.
214
A. Travaux Pratiques A.5. Fichiers séparés
F IGURE A.4 – Corps célestes et jeu de tir. . .
Chocs élastiques
17. Tout faire évoluer, tout faire rebondir :

On retourne dans le projet Gravitation. Tout faire bouger, y compris les soleils.
Utiliser, pour les chocs élastiques, la fonction Chocs (qui fait rebondir les deux
corps). Faire en sorte que lors de l’initialisation les soleils ne s’intersectent pas.
215
A.6. Images A. Travaux Pratiques
A.6 Images
F IGURE A.5 – Deux images et différents traitements de la deuxième (négatif, flou, relief,
déformation, contraste et contours).
Dans ce TP, nous allons jouer avec les tableaux bidimensionnels statiques (mais
stockés dans des tableaux 1D) puis dynamiques. Pour changer de nos passionnantes
matrices, nous travaillerons avec des images (figure A.5).
A.6.1 Allocation
1. Récupérer le projet :
Télécharger le fichier Tp6_Initial.zip sur la page habituelle, le décompresser
et lancer votre environnement de développement préféré, QtCreator.
2. Saturer la mémoire :
Rien à voir avec ce qu’on va faire après mais il faut l’avoir fait une fois. . . Faire,
dans une boucle infinie, des allocations de 1000000 entiers sans désallouer, cha-
cune suivie d’une pause de 0.5 seconde, et regarder la taille du process grandir.
(Utiliser Ctrl+Shift+Echap pour accéder au gestionnaire de tâches sous Win-
dows). Compiler en mode Release pour utiliser la “vraie” gestion du tas (Le mode
Debug utilise une gestion spécifique qui aide à trouver les bugs et se comporte
différemment. . . )
A.6.2 Tableaux statiques

3. Niveaux de gris :
Une image noir et blanc est représentée par un tableau de pixels de dimensions
constantes W=300 et H=200. Chaque pixel (i,j) est un byte (entier de 0 à 255)
216
A. Travaux Pratiques A.6. Images
allant de 0 pour le noir à 255 pour le blanc. L’origine est en haut à gauche, i est
l’horizontale et j la verticale. Dans un tableau de byte mono-dimensionnel t de
taille W*H mémorisant le pixel (i,j) en t[i+W*j] :
— Stocker une image noire et l’afficher avec putGreyImage(0,0,t,W,H).
— Idem avec une image blanche.
— Idem avec un dégradé du noir au blanc (attention aux conversions entre
byte et double).
— Idem avec t(i, j) = 128 + 128 sin(4πi/W ) sin(4πj/H) (cf figure A.5). Utiliser
# i n c l u d e <cmath>
pour avoir les fonctions et les constantes mathématiques : M_PI vaut π.
4. Couleurs :
Afficher, avec putColorImage(0,0,r,g,b,W,H), une image en couleur sto-
ckée dans trois tableaux r, g et b (rouge, vert, bleu). Utiliser la fonction click()
pour attendre que l’utilisateur clique avec la souris entre l’affichage précédent et
ce nouvel affichage.
A.6.3 Tableaux dynamiques

5. Dimensions au clavier :
Modifier le programme précédent pour que W et H ne soient plus des constantes
mais des valeurs entrées au clavier. Ne pas oublier de désallouer.
A.6.4 Charger un fichier

6. Image couleur :
La fonction loadColorImage(srcPath("ppd.jpg"),r,g,b,W,H); charge
le fichier "ppd.jpg" qui est dans le répertoire contenant les sources (srcPath),
alloue elle-même les tableaux r,g,b, les remplit avec les pixels de l’image, et
affecte aussi W et H en conséquence. Attention : ne pas oublier de désallouer les
tableaux r,g,b avec delete [] après usage.
— Charger cette image et l’afficher. Ne pas oublier les désallocations.
7. Image noir et blanc :
La fonction loadGreyImage(srcPath("ppd.jpg"),t,W,H) fait la même chose
mais convertit l’image en noir et blanc. Afficher l’image en noir et blanc. . .
A.6.5 Fonctions
8. Découper le travail :
On ne garde plus que la partie noir et blanc du programme. Faire des fonctions
pour allouer, détruire, afficher et charger les images :
byte ∗ AlloueImage ( i n t W, i n t H) ;
void DetruitImage ( byte ∗ I ) ;
void AfficheImage ( byte ∗ I , i n t W, i n t H) ;
byte ∗ ChargeImage ( char ∗ name , i n t &W, i n t &H) ;
217
A.6. Images A. Travaux Pratiques
9. Fichiers :
Créer un image.cpp et un image.h en conséquence. . .
A.6.6 Structure
10. Principe :
Modifier le programme précédent pour utiliser une structure :
s t r u c t Image {
byte ∗ t ;
i n t w, h ;
};
AlloueImage() et ChargeImage() pourront retourner des Image.
11. Indépendance :
Pour ne plus avoir à savoir comment les pixels sont stockés, rajouter :
byte Get ( Image I , i n t i , i n t j ) ;
void S e t ( Image I , i n t i , i n t j , byte g ) ;
12. Traitements :
Ajouter dans main.cpp différentes fonctions de modification des images
Image N e g a t i f ( Image I ) ;
Image Flou ( Image I ) ;
Image R e l i e f ( Image I ) ;
Image Contours ( Image I , double s e u i l ) ;
Image Deforme ( Image I ) ;
et les utiliser :
(a) Negatif : changer le noir en blanc et vise-versa par une transformation
affine.
(b) Flou : chaque pixel devient la moyenne de lui-même et de ses 8 voisins.
Attention aux pixels du bords qui n’ont pas tous leurs voisins (on pourra ne
pas moyenner ceux-là et en profiter pour utiliser l’instruction continue !).
(c) Relief : la dérivée suivant une diagonale donne une impression d’ombres
projetées par une lumière rasante.
— Approcher cette dérivée par différence finie : elle est proportionnelle à
I(i + 1, j + 1) − I(i − 1, j − 1).
— S’arranger pour en faire une image allant de 0 à 255.
(d) Contours : calculer par différences finies la dérivée horizontale dx = (I(i +
1, j) − I(i
p 2− 1, j))/2 et la dérivée verticale dy , puis la norme du gradient
2
|∇I| = dx + dy et afficher en blanc les points où cette norme est supérieure
à un seuil.
(e) Deforme : Construire une nouvelle image sur le principe J(i, j) = I(f (i, j))
avec f bien choisie. On pourra utiliser un sinus pour aller de 0 à W-1 et de 0
à H-1 de façon non linéaire.
218
A. Travaux Pratiques A.6. Images
A.6.7 Suite et fin

13. Tout remettre au propre : il est probable que vous ayez mis en commentaire les
appels au code des premières questions pour ne pas perdre de temps en test lors
du développement. Rétablir toutes ces opérations, et vérifiez une dernière fois
que tout se déroule bien du début à la fin en relançant le programme.
14. S’il reste du temps, s’amuser :
— Rétrécir une image.
— Au lieu du négatif, on peut par exemple changer le contraste, par exemple
en multipliant la différence entre un pixel et la moyenne de ses voisins :
J(i, j) = I(i, j)+λ (I(i, j) − (I(i − 1, j) + I(i + 1, j) + I(i, j − 1) + I(i, j + 1))/4)
219
A.7. Premiers objets et dessins de fractales A. Travaux Pratiques
A.7 Premiers objets et dessins de fractales
F IGURE A.6 – Fractales. . .
Dans ce TP, nous allons nous essayer à la programmation objet. Nous allons trans-
former une structure vecteur en une classe et l’utiliser pour dessiner des courbes frac-
tales (figure A.6).
A.7.1 Le triangle de Sierpinski

1. Récupérer le projet :
Télécharger le fichier Tp7_Initial.zip sur la page habituelle, le décompres-
ser et lancer votre IDE. Etudier la structure Vector définie dans les fichiers
Vector.cpp et Vector.h.
2. Interfaçage avec Imagine++ :
La structure Vector ne comporte pas de fonction d’affichage graphique. Ajouter
dans main.cpp des fonctions drawLine et drawTriangle prenant des Vector
en paramètres. Il suffit de rebondir sur la fonction
void drawLine ( i n t x1 , i n t y1 , i n t x2 , i n t y2 , c o n s t Color& c , i n t pen_w )
d’Imagine++. Le dernier paramètre contrôle l’épaisseur du trait.
3. Triangle de Sierpinski :
C’est la figure fractale choisie par l’ENPC pour son logo. La figure ci-dessous
illustre sa construction.
Écrire une fonction récursive pour dessiner le triangle de Sierpinski. Cette fonc-
F IGURE A.7 – Construction du triangle de Sierpinski.
220
A. Travaux Pratiques A.7. Premiers objets et dessins de fractales
tion prendra en paramètres les trois points du triangle en cours et l’epaisseur du

trait. Les trois sous-triangles seront dessinés avec un trait plus fin. Ne pas oublier
la condition d’arrêt de la récursion !
Utiliser cette fonction dans le main en lui fournissant un triangle initial d’épais-
seur 6.
A.7.2 Une classe plutôt qu’une structure

4. Classe vecteur :
Transformer la structure Vector en une classe. Y incorporer toutes les fonctions
et les opérateurs. Passer en public le strict nécessaire. Faire les modifications né-
cessaires dans main.cpp.
5. Accesseurs pour les membres :
Rajouter des accesseurs en lecture et en écriture pour les membres, et les utiliser
systématiquement dans le programme principal. L’idée est de cacher aux utilisa-
teurs de la classe Vector les détails de son implémentation.
6. Dessin récursif d’un arbre :
Nous allons maintenant dessiner un arbre. Pour cela il faut partir d’un tronc et
remplacer la deuxième moitié de chaque branche par deux branches de même
longueur formant un angle de 20 degrés avec la branche mère. La figure ci-
dessous illustre le résultat obtenu pour différentes profondeurs de récursion.
Écrire une fonction récursive pour dessiner une telle courbe. Vous aurez besoin
F IGURE A.8 – Construction de l’arbre.
de la fonction Rotate de la classe Vector.

Il est naturel de penser à effacer la moitié d’un segment précédent pour tracer
les nouvelles branches, mais ce n’est pas une très bonne idée : les segments sont
discrétisés, et un sous-segment discrétisé ne passera pas forcément par les mêmes
pixels que le segment père, d’où des taches résiduelles lors de l’effacement. La
même remarque s’appliquera pour la courbe de Koch par la suite.
A.7.3 Changer d’implémentation

7. Deuxième implémentation :
Modifier l’implémentation de la classe Vector en remplaçant les membres double x,y;
par un tableau double coord[2];. Quelles sont les modifications à apporter dans
main.cpp ?
8. Vecteurs de dimension supérieure :
L’avantage de cette dernière implémentation est qu’elle se généralise aisément à
des vecteurs de dimension supérieure. Placer une constante globale DIM égale à
221
A.7. Premiers objets et dessins de fractales A. Travaux Pratiques
2 au début de Vector.h et rendre la classe Vector indépendante de la dimen-

sion.
NB : la fonction Rotate et les accesseurs que nous avons écrits ne se généra-
lisent pas directement aux dimensions supérieures. Les laisser tels quels pour
l’instant. . .
A.7.4 Le flocon de neige

9. Courbe de Koch :
Cette courbe fractale s’obtient en partant d’un segment et en remplaçant le deuxième
tiers de chaque segment par deux segments formant la pointe d’un triangle équi-
latéral.
Écrire une fonction récursive pour dessiner une courbe de Koch.
F IGURE A.9 – Construction de la courbe de Koch.
10. Flocon de neige :

Il s’obtient en construisant une courbe de Koch à partir de chacun des côtés d’un
triangle équilatéral.
222
A. Travaux Pratiques A.8. Tron
F IGURE A.10 – Jeu de Tron.
A.8 Tron
Dans ce TP, nous allons programmer le jeu TRON. Il s’agit d’un jeu à 2 joueurs,
dans lequel chaque joueur pilote un mobile qui se déplace à vitesse constante et laisse
derrière lui une trace infranchissable. Le premier joueur qui percute sa propre trace ou
celle de son adversaire a perdu. Ce TP est assez ambitieux et s’approche d’un mini-
projet. Il nous occupera plusieurs séances.
A.8.1 Serpent
Nous allons procéder en deux temps. D’abord programmer un jeu de Serpent à un
joueur. Le programme serpent.exe (sous Windows) vous donne une idée du résul-
tat recherché. Dans ce jeu, le joueur pilote un Serpent qui s’allonge petit à petit (d’un
élément tous les x tours, avec la convention que la longueur totale est bornée à nmax
éléments). Il s’agit de ne pas se rentrer dedans ni de percuter les murs.
La solution de départ comporte deux fichiers, utils.h et utils.cpp, qui contiennent

une structure point (qu’il faudra éventuellement étoffer de méthodes utiles) et une
fonction destinée à récupérer les touches clavier pour l’interaction avec les joueurs.
Il s’agit ici de concevoir un objet Serpent doté des méthodes adéquates, plus une
fonction jeu_1p exploitant les capacités du Serpent pour reproduire le comportement
désiré. On pourra dans un premier temps ne pas gérer les collisions (avec le bord et
avec lui-même), et ne les rajouter que dans un second temps. Votre travail se décom-
pose en 6 étapes :
1. (sur papier) Définir l’interface de la classe Serpent (c’est-à-dire lister toutes les
fonctionnalités nécessaires).
2. (sur papier) Réfléchir à l’implémentation de la classe Serpent : comment stocker
les données ? comment programmer les différentes méthodes ? (lire en prélimi-
naire les remarques du paragraphe suivant).
3. Dans un fichier serpent.h, écrire la déclaration de votre classe Serpent : ses
membres, ses méthodes, ce qui est public, ce qui ne l’est pas.
4. Soumettre le résultat de vos réflexions à votre enseignant pour valider avec lui les choix
retenus.
223
A.8. Tron A. Travaux Pratiques
5. Implémenter la classe Serpent (c’est-à-dire programmer les méthodes que vous

avez déclarées).
6. Programmer la fonction jeu_1p utilisant un Serpent.
Remarque : Dans le fichier utils.h sont définis :
1. 4 entiers gauche, bas, haut, droite de telle manière que :
(a) la fonction x → (x + 1)%4 transforme gauche en bas, bas en droite, droite en
haut et haut en gauche ; cette fonction correspond donc à un quart de tour
dans le sens trigonométrique.
(b) la fonction x → (x + 3)%4 transforme gauche en haut, haut en droite, droite
en bas et bas en gauche ; 7 cette fonction correspond donc à un quart de tour
dans le sens des aiguilles d’une montre.
2. un tableau de 4 points dir de telle manière que, moyennant la définition d’une
fonction permettant de faire la somme de deux points, la fonction p → p + dir[d]
renvoie :
(a) pour d = gauche le point correspondant au décalage de p de 1 vers la
gauche.
(b) pour d = haut le point correspondant au décalage de p de 1 vers la haut.
(c) pour d = droite le point correspondant au décalage de p de 1 vers la droite.
(d) pour d = bas le point correspondant au décalage de p de 1 vers la bas.
A.8.2 Tron
A partir du jeu de Serpent réalisé précédemment, nous allons facilement pouvoir
implémenter le jeu Tron. Le programme tron.exe vous donne une idée du résultat
recherché. Le principe de ce jeu est que chaque joueur pilote une moto qui laisse der-
rière elle une trace infranchissable. Le but est de survivre plus longtemps que le joueur
adverse.
1. Passage à deux joueurs.
A partir de la fonction jeu_1p, créer une fonction jeu_2p implémentant un
jeu de serpent à 2 joueurs. On utilisera pour ce joueur les touches S, X, D et F. 8
La fonction Clavier() renverra donc les entiers int ( ’S’ ), int ( ’X’), int ( ’D’) et
int ( ’F’). Remarque : on ne gèrera qu’une touche par tour, soit un seul appel à la
fonction Clavier() par tour, sinon les serpents seront en concurrence pour le
clavier.
2. Ultimes réglages
(a) Gérer la collision entre les deux serpents.
(b) Le principe de Tron est que la trace des mobiles reste. Pour implémenter
cela, il suffit d’allonger nos serpents à chaque tour.
7. Moralement, (x + 3)%4 = (x − 1)%4, mais pour le C++ −1%4 = −1
8. Les touches A, Z, Q et W ne sont pas dans la bonne configuration sur un clavier Qwerty, les éviter
donc.
224
A. Travaux Pratiques A.8. Tron
A.8.3 Graphismes
Petit bonus pour les rapides : nous allons voir comment gérer des graphismes un
peu plus sympas que les rectangles uniformes que nous avons utilisés jusqu’ici. L’ob-
jectif est de remplacer le carré de tête par une image que l’on déplace à chaque tour.
Nous allons utiliser pour cela les NativeBitmap d’Imagine++, qui sont des images
à affichage rapide. Pour charger une image dans une NativeBitmap on procède ainsi :
/ / E n t i e r s p a s s é s p a r r é f é r e n c e l o r s du c h a r g e m e n t d e l ’ i m a g e p o u r
/ / qu ’ y s o i e n t s t o c k é e s l a l a r g e u r e t l a h a u t e u r d e l ’ i m a g e
i n t w, h ;
/ / Chargement d e l ’ i m a g e
byte ∗ rgb ;
loadColorImage ( " n o m _ f i c h i e r . bmp" , rgb ,w, h ) ;
/ / D é c l a r a t i o n de l a NativeBitmap
NativeBitmap ma_native_bitmap (w, h ) ;
/ / On p l a c e l ’ i m a g e d a n s l a N a t i v e B i t m a p
ma_native_bitmap . setColorImage ( 0 , 0 , rgb ,w, h ) ;
L’affichage d’une NativeBitmap à l’écran se fait alors en utilisant la fonction
d’Imagine++ :
void putNativeBitmap ( i n t x , i n t y , NativeBitmap nb )
1. Remplacer dans le serpent l’affichage de la tête par l’affichage d’une image. On

pourra utiliser les images moto_blue.bmp et moto_red.bmp fournies.
2. Utiliser l’image explosion.bmp lors de la mort d’un des joueurs.
A.8.4 Peaufiner le code

Pour faire un code propre et dont vous pourrez être fiers, respectez les consignes
suivantes :
— Ne pas faire deux devoirs séparés, la classe Serpent étant partagée par les deux
programmes. Votre CMakeLists.txt a donc deux instructions add_executable.
— La classe Serpent a un/des constructeur(s).
— La classe Serpent a un destructeur, mais seulement si nécessaire. Indice : y a-t-il
allocation dynamique de mémoire ?
— Pas de copie de Serpent inutile lors d’un passage en paramètre de fonction.
Indice : les objets de type Serpent sont-ils passés par référence ? Voir le cours
sur le constructeur par copie.
— Seules les méthodes utilisées par l’extérieur sont publiques. Les autres doivent
être privées.
— Les méthodes qui ne modifient pas le Serpent sont const.
— L’indentation est correcte. Est-il encore nécessaire de rappeler cette évidence ?
— Les bitmaps sont lus avec srcPath et le programme stoppe s’il ne les trouve pas.
225
B. Imagine++
Annexe B
Imagine++
Imagine++ est un ensemble de bibliothèques permettant de faire simplement du

graphisme et de l’algèbre linéaire. Elles s’appuient pour cela sur les projets Qt (gra-
phisme 2D et 3D) et Eigen (algèbre linéaire). Ceux-ci proposent une richesse de pos-
sibilités bien plus importantes que Imagine++ mais en contrepartie Imagine++ est
plus simple à utiliser.
Imagine++ est un logiciel libre, vous pouvez donc l’utiliser et le distribuer à votre
guise (et gratuitement !), mais si vous le distribuez sous une forme modifiée vous de-
vez offrir selon les mêmes termes les sources de vos modifications. Une documentation
complète est disponible sur la page Web d’Imagine++, détaillant l’insallation et l’uti-
lisation.
Pour utiliser un module, par exemple Images, un fichier source doit l’inclure
# i n c l u d e <Imagine/Images . h>
pour une compilation correcte, et votre fichier CMakeLists.txt doit comporter
ImagineUseModule ( MonProgramme Images )
pour que l’édition de liens (link) réussisse.
Tout est englobé dans un namespace Imagine, donc si vous voulez éviter de pré-
fixer les noms par Imagine:: vous devez utiliser dans votre code
using namespace Imagine ;
B.1 Common
Le module Common définit entre autres la classe Color codée par un mélange de
rouge, vert et bleu, la quantité de chacun codée par un entier entre 0 et 255 :
Color n o i r = Color ( 0 , 0 , 0 ) ;
Color b l a n c = Color ( 2 5 5 , 2 5 5 , 2 5 5 ) ;
Color rouge = Color ( 2 5 5 , 0 , 0 ) ;
Un certain nombre de constantes de ce type sont déjà définies : BLACK, WHITE, RED,
GREEN, BLUE, CYAN, MAGENTA, YELLOW.
Un type byte (synonyme de unsigned char) est défini pour coder une valeur
entière entre 0 et 255.
B.2. Graphics B. Imagine++
Très pratique, srcPath fait précéder la chaîne de caractère argument par le chemin
complet du répertoire contenant le fichier source. L’équivalent pour un argument de
type string est stringSrcPath :
c o n s t char ∗ f i c h i e r = s r c P a t h ( " m o n _ f i c h i e r . t x t " ) ;
s t r i n g s = " mon_fichier . t x t " ;
s = stringSrcPath ( s ) ;
En d’autres termes, le fichier sera trouvé quel que soit l’emplacement de l’exécutable.
La classe template FArray s’utilise pour des tableaux de taille petite et connue à
la compilation (allocation statique). Pour des tableaux de taille non connue à la com-
pilation (allocation dynamique), utiliser Array. Pour les matrices et vecteurs, utiliser
FMatrix et FVector, utilisant l’allocation statique comme indiqué par le préfixe F
(fixed). Les équivalents dynamiques sont dans LinAlg.
Pratique aussi, l’appel de fonction intRandom(5,10) renvoie un nombre entier aléa-
toire dans l’intervalle [5, 10]. Pour ne pas obtenir à chaque exécution du programme la
même suite de nombres aléatoires, il faut faire appel à initRandom(), fonction qui ne
doit être appelée qu’une fois, typiquement au début du main.
B.2 Graphics
Le module Graphics propose du dessin en 2D et 3D. Les coordonnées 2D sont en
pixel, l’axe des x est vers la droite et l’axe des y vers le bas (attention, ce n’est pas le
sens mathématique usuel !). Le point (0,0) est donc le coin haut-gauche de la fenêtre
(pour les fonctions de tracé) ou de l’écran (pour openWindow).
openWindow ( 5 0 0 , 5 0 0 ) ; / / T a i l l e d e f e n ê t r e
drawRect ( 1 0 , 1 0 , 4 8 0 , 4 8 0 ,RED ) ; / / Coin haut −g a u c h e ( 1 0 , 1 0 ) ,
/ / l a r g e u r 4 8 0 , h a u t e u r 480
drawLine ( 1 0 , 1 0 , 4 9 0 , 4 9 0 ,BLUE ) ; / / D i a g o n a l e
Window w = openWindow ( 1 0 0 , 1 0 0 ) ; / / A u t r e f e n ê t r e
setActiveWindow (w) ; / / S é l e c t i o n p o u r l e s p r o c h a i n s t r a c é s
drawString ( 1 0 , 1 0 , "Du t e x t e " , MAGENTA) ; / / M e t t r e du t e x t e
endGraphics ( ) ; / / A t t e n d un c l i c s o u r i s a v a n t d e f e r m e r l e s f e n ê t r e s
Si on a beaucoup de dessins à faire à la suite et qu’on veut n’afficher que le résultat
final (c’est plus esthétique), on encadre le code de tracé par :
noRefreshBegin ( ) ;
...
noRefreshEnd ( ) ;
Pour faire une animation, il est utile de faire une petite pause entre les images pour
réguler la cadence :
m i l l i S l e e p ( 5 0 ) ; / / Temps en m i l l i s e c o n d e s
Attention cependant à ne pas intercaler une telle commande entre un noRefreshBegin
et un noRefreshEnd, car rien ne s’afficherait pendant cette pause.
On peut charger une image (loadGreyImage, loadColorImage) ou sauvegar-
der (saveGreyImage, saveColorImage) dans un fichier. Attention, ces fonctions
allouent de la mémoire qu’il ne faut pas oublier de libérer après usage.
228
B. Imagine++ B.3. Images
byte ∗ g ;
i n t l a r g e u r , hauteur ;
i f ( ! loadGreyImage ( s r c P a t h ( " image . j p g " ) , g , l a r g e u r , hauteur ) ) {
c e r r << " I m p o s s i b l e d ’ o u v r i r l e f i c h i e r "
<< s r c P a t h ( " image . j p g " ) << endl ;
exit (1);
}
/ / D e s s i n e a v e c c o i n h a u t g a u c h e en ( 0 , 0 ) :
putGreyImage ( 0 , 0 , g , l a r g e u r , hauteur ) ;
d e l e t e [ ] g ; / / Ne p a s o u b l i e r !
A noter srcPath, défini dans Common, qui indique de chercher dans le dossier conte-
nant les fichiers source.
En fait, pour éviter de gèrer soi-même la mémoire des images, il existe une classe
dédiée à cela :
B.3 Images
Le module Images gère le chargement, la manipulation et la sauvegarde des images.
Image<byte > im ; / / Image en n i v e a u x d e g r i s
i f ( ! load ( im , s r c P a t h ( " f i c h i e r _ i m a g e . png " ) ) ) {
c e r r << " I m p o s s i b l e d ’ o u v r i r l e f i c h i e r "
<< s r c P a t h ( f i c h i e r _ i m a g e . png ’ ’ ) << endl ;
exit (1);
}
d i s p l a y ( im ) ; / / D e s s i n e d a n s l a f e n ê t r e a c t i v e
im ( 0 , 0 ) = 1 2 8 ; / / Met l e p i x e l en g r i s
save ( im , " f i c h i e r _ i m a g e 2 . png " ) ; / / S a u v e g a r d e l ’ i m a g e d a n s un f i c h i e r
Attention : la recopie et l’affectation (opérateur =) sont des opérations peu coû-
teuses qui en fait ne font qu’un lien entre les images, sans réelle copie. Ce qui fait que
la modification de l’une affecte l’autre :
Image<Color > im1 ( 1 0 0 , 1 0 0 ) ;
Image<Color > im2 = im1 ; / / C o n s t r u c t e u r p a r r e c o p i e
im1 ( 1 0 , 1 0 ) = CYAN;
a s s e r t ( im2 ( 1 0 , 1 0 ) == CYAN) ; / / im2 a é t é a f f e c t é e
Pour faire une vraie copie plutôt qu’un lien, on utilise :
im2 = im1 . c l o n e ( ) ;
im1 ( 1 0 , 1 0 ) = CYAN; / / N ’ a f f e c t e p a s im2
Ainsi, si on passe une image comme paramètre d’une fonction, puisque c’est le
constructeur par copie qui est appelé, tout se passe comme si on avait passé par réfé-
rence :
void f ( Image<Color > im ) { / / P a s s a g e p a r v a l e u r
im ( 1 0 , 1 0 ) = CYAN;
}
f ( im1 ) ; / / M o d i f i e quand même l e p i x e l ( 1 0 , 1 0 )
229
B.4. LinAlg B. Imagine++
Une erreur courante est de chercher à lire ou écrire à des coordonnées au-delà des
bornes du tableau, typiquement une erreur dans un indice de boucle.
B.4 LinAlg
Le module LinAlg propose l’algèbre linéaire avec des classes matrice et vecteur.
Matrix < f l o a t > I ( 2 , 2 ) ; / / T a i l l e 2 x2
I . f i l l (0.0 f ) ; / / Matrice nulle
I (0 ,0)= I (1 ,1)=1.0 f ; / / Matrice i d e n t i t é
cout << " det ( I )= " << det ( I ) << endl ; / / D é t e r m i n a n t
Les opérateurs d’addition (matrice+matrice, vecteur+vecteur), soustraction (matrice-
matrice, vecteur-vecteur) et multiplication (matrice*matrice, matrice*vecteur) sont bien
sûr définis.
Comme pour les images, attention de ne pas sortir des bornes en accédant aux
éléments des matrices et vecteurs !
Une fonction très utile est linSolve pour résoudre un système linéaire.
B.5 Installation
Examinons le fichier CMakeLists.txt d’un programme utilisant Imagine++.
cmake_minimum_required(VERSION 2.6)
find_package(Imagine REQUIRED)
project(Balle)
add_executable(Balle Balle.cpp)
ImagineUseModules(Balle Graphics)
Pour que le find_package fonctionne, il est parfois nécessaire de définir la variable
Image_DIR. Cette commande va charger le fichier
/usr/share/Imagine++/CMake/ImagineConfig.cmake
quit contient des commandes CMake, dont ImagineUseModules. Cette dernière fait
deux choses :
— Indique où chercher lors des #include, comme par exemple dans le dossier
/usr/share/Imagine++/include
Ainsi, l’instruction
#include "Imagine/Graphics.h"
inclura le fichier
/usr/share/Imagine++/include/Imagine/Graphics.h
— Indique qu’il faut lier la bibliothèque libImageGraphics.a lors de l’édition de
liens (link) ; elle se trouve dans
/usr/share/Imagine++/lib
230
C. Compilateur, CMake, Linker, Qt. . . Au secours !
Annexe C
Compilateur, CMake, Linker, Qt. . . Au

secours !
D’accord, tout cela a l’air bien compliqué, et en effet ce n’est pas si simple. Néanmoins, il
faut en passer par là, et nous allons voir que ce n’est pas si difficile à comprendre, malgré l’effroi
que nous pouvons ressentir face à une telle accumultation d’outils. La lecture de cette annexe
n’est pas nécessaire pour les utiliser, mais elle devrait aider à comprendre comment tout cela
s’imbrique.
C.1 Compilation
C.1.1 Compilateur et linker
Commençons par le principe de base : pour passer du code source, c’est-à-dire des
fichiers d’extension .h et .cpp 1 , à un programme exécutable, il faut lancer le build, qu’on
appelle souvent abusivement compilation, alors que cette compilation proprement dite
n’est qu’une partie du processus 2 . Celle-ci est composée en fait de deux phases, com-
pilation (faite par le compilateur) suivie d’édition de liens (faite par le linker). Le rôle
du linker est de rassembler les produits de la phase de compilation, les fichiers objet
(d’extension .o ou .obj), et d’éventuelles bibliothèques (libraries en anglais, que les in-
formaticiens francisent souvent à tort en librairies), qui ne sont en fait que des fichiers
de type archive (comme un zip) de fichiers objet. Ceci est résumé par le schéma de la
Figure C.1.
Plusieurs choses sont à remarquer :
— Le compilateur est lancé indépendamment sur chaque source .cpp, au point que
ces compilations peuvent être lancées en parallèle. Une conséquence importante
est que la modification d’un .cpp ne nécessite pas la recompilation des autres,
d’où gain de temps du build.
1. Parfois on remplace l’extension .h par .hpp pour éviter de confondre avec les fichiers header du
langage C. On rencontre aussi les conventions .hxx et .cxx, car le + pourrait être mal géré dans le nom
d’un fichier par certains systèmes d’exploitation, et finalement le x n’est qu’un + tourné.
2. On fait donc là une synecdoque. Comme quoi faire de l’ingénierie ne prive pas d’avoir du goût
pour les figures littéraires !
C.1. Compilation C. Compilateur, CMake, Linker, Qt. . . Au secours !
fichier1.cpp compilateur fichier1.o
fichier2.cpp compilateur fichier2.o
fichier3.cpp compilateur fichier3.o linker programme
libImagineGraphics.a
libQtCore.so
F IGURE C.1 – Phases de compilation et d’édition de liens. Les extensions sont les
conventions des systèmes Unix (Linux et Mac), sous Windows les fichiers objet sont
en .obj, les bibliothèques en .lib et le programme en .exe.
— Les fichier header en .h ne sont pas passés directement au compilateur, mais ils le
sont indirectement par les .cpp qui font des #include de ces .h. Comme plu-
sieurs .cpp peuvent faire un #include "fic1.h", ce fichier passe plusieurs
fois par le compilateur. Il est donc essentiel que le compilateur ne génère pas de
symboles dus à fic1.h, comme des variables globales (à éviter tant que possible
de toute façon) ou des définitions de fonction, mais seulement des déclarations
(de classes, de fonctions, de constantes) 3 . Sinon, lors de l’édition de liens, il va
échouer en signalant : Multiply defined symbol...
— Le rôle de l’éditeur de liens est de vérifier que chaque fonction ou méthode de
classe utilisée 4 soit définie une et une seule fois, c’est-à-dire dans un unique .o
ou bibliothèque. De plus, il vérifie que la fonction d’entrée du programme, le
main, est bien défini également (une seule fois).
— Les bibliothèques se présentent sous deux formes : statiques (extension .a) et dy-
namiques (extension .so, comme shared object). Lors de l’édition de liens,
les symboles des bibliothèques statiques utilisés sont inclus dans le programme
résultant, alors que ceux des bibliothèques dynamiques ne le sont pas, l’éditeur
de liens vérifie juste leur présence. L’avantage de ces dernières est que le pro-
gramme est moins volumineux en mémoire, que plusieurs programmes utilisant
la même bibliothèque ne nécessitent qu’un unique chargement en mémoire de
cette bibliothèque lors de leur lancement, et que la correction d’une faille de sécu-
rité ou d’un bug dans une bibliothèque dynamique ne nécessite pas de recompi-
ler tous les programmes l’utilisant et de les redistribuer aux utilisateurs (pourvu
qu’on prenne garde à seulement corriger ces bugs sans changer les arguments des
fonctions, etc). La contrepartie, c’est que le programme exécutable ne peut pas se
lancer directement car il est incomplet, il a besoin de trouver les bibliothèques
dynamiques dont il dépend.
En fait, sous Windows, les bibliothèques dynamiques sont scindées en deux : le .lib
sert lors de l’édition de liens (penser à lui comme à une sorte de header pour la bi-
bliothèque) tandis que la partie .dll sert lors du lancement du programme. Le pro-
3. Les exceptions sont les fonctions inline, les méthodes de classes définies directement dans la
classe, qui sont en fait aussi inline, et les fonctions ou méthodes template, qui sont très particu-
lières car elles ne peuvent être réellement compilées que lorsque les types des paramètres template sont
connus, on parle d’instantiation de ces templates.
4. Une fonction ou méthode déclarée mais non appelée ne provoque pas d’erreur mais est simplement
considérée comme superflue par l’éditeur de liens.
232
C. Compilateur, CMake, Linker, Qt. . . Au secours ! C.2. En ligne de commande
gramme ne peut se lancer s’il ne trouve pas les .dll dont il a besoin 5 . On peut voir les
bibliothèques dynamiques dont dépendent un programme exécutable avec les outils
ldd (Linux), otool (Mac) et depend.exe (Windows).
C.2 En ligne de commande
Voici un exemple de ligne de compilation d’un fichier test.cpp, dont le fichier

objet résultant s’appelle test.o :
/usr/bin/c++ -DQT_CORE_LIB -DQT_GUI_LIB -DQT_NO_DEBUG -DQT_OPENGL_LIB
-DQT_WIDGETS_LIB -O3 -DNDEBUG
-I/home/pascal/Ponts/svn/ImagineQt/Imagine/Common/src
-I/home/pascal/Ponts/svn/ImagineQt/Imagine/Graphics/src -I/usr/include/qt5
-I/usr/include/qt5/QtCore -I/usr/lib/x86_64-linux-gnu/qt5/mkspecs/linux-g++-64
-I/usr/include/qt5/QtWidgets -I/usr/include/qt5/QtGui
-I/usr/include/qt5/QtOpenGL
-DSRCDIR="/home/pascal/Ponts/svn/ImagineQt/Imagine/Graphics/test"
-o CMakeFiles/ImagineGraphicsTest.dir/test.o
-c /home/pascal/Ponts/svn/ImagineQt/Imagine/Graphics/test/test.cpp
Le compilateur s’appelle c++, les options -D font comme si test.cpp comportait
un #define correspondant. L’option -O3 indique l’optimisation du code niveau 3 (le
plus élevé). Les options -I indiquent les dossiers où les #include doivent chercher les
fichiers header s’ils ne les trouvent pas dans le dossier courant. Maintenant, l’édition
de lien de ce seul fichier objet avec les bibliothèques dont il a besoin :
/usr/bin/c++ CMakeFiles/ImagineGraphicsTest.dir/test.o
-o ImagineGraphicsTest ../src/libImagineGraphics.a
/usr/lib/x86_64-linux-gnu/libQt5Core.so.5.2.1
/usr/lib/x86_64-linux-gnu/libQt5Widgets.so.5.2.1
/usr/lib/x86_64-linux-gnu/libQt5Gui.so.5.2.1
/usr/lib/x86_64-linux-gnu/libQt5OpenGL.so.5.2.1
-lGLU -lGL -lSM -lICE -lX11 -lXext
Le programme résultant s’appelle ImagineGraphicsTest, il utilise la bibliothèque
statique libImagineGraphics.a et les bibliothèques dynamiques Qt, ainsi que les
bibliothèques standard libGLU.so, libGL.so, etc. Ces dernières sont installées dans
des emplacements connus du linker, donc on n’a pas besoin de lui dire où chercher,
mais on aurait pu lui donner des indices avec des options -L, comme les -I de la com-
pilation. En fait le programme c++ lancé ainsi comprend qu’on est en train de faire de
l’édition de liens et non une compilation, et appelle en fait le linker.
On voit donc que pour utiliser une bibliothèque, il faut (1) indiquer au compila-
teur où se trouvent ses fichiers header .h, (2) indiquer au linker où se trouvent ces
bibliothèques.
5. Il cherche pour cela dans le dossier contenant le programme et dans la liste des dossiers indiqués
par la variable d’environnement PATH. Sous Linux et Mac, la variable équivalente pour chercher les .so
s’intitule LD_LIBRARAY_PATH.
233
C.3. Make et CMake C. Compilateur, CMake, Linker, Qt. . . Au secours !
C.3 Make et CMake

On voit que les lignes ci-dessus sont complexes et la phase de build serait bien
fastidieuse si on devait faire tout cela soi-même. A ce point entre en jeu l’automate de
build nommé make. Celui-ci lit un fichier texte nommé Makefile qui décrit les dépen-
dances entre fichiers et les règles pour regénérer les dependances lorsque c’est néces-
saire. Ainsi, un Makefile pour le programme ci-dessus indiquerait que le programme
ImagineGraphicsTest dépend de test.o qui lui-même dépend de test.cpp.
Mais cela ne s’arrête pas là, puisque test.cpp fait des #include de fichiers header
.h, qui eux-mêmes peuvent dépendre d’autres .h par des #include, etc.
Les lignes de génération de test.o et de ImagineGraphicsTest sont celles de
compilation et de link de l’exemple ci-dessus. Le programme make se fie au temps de
modification des fichiers pour savoir ce qui est à jour, et ne nécessite aucune action, et
ce qui ne l’est pas, et nécessite d’appliquer les règles de regénération : si un fichier A,
dont dépend un fichier B, a été modifié plus récemment que B (ou que B n’existe pas),
la règle de regénération de B est appliquée. Ainsi, l’unique commande make permet
d’effectuer à la fois la compilation et le link. Lancer make deux fois de suite fait que le
deuxième appel ne fait rien, puisque tous les fichiers sont à jour d’après leur heure de
modification. C’est le comportement de moindre effort le plus raisonnable.
Pour trouver toutes les dépendances d’un fichier .cpp, il faut trouver ses #include
et suivre ceux-ci transitivement. Le compilateur (en fait, la phase préliminaire de la
compilation effectuée par le préprocesseur, à qui toutes les instructions en # sont adres-
sées) en est tout à fait capable et écrire ces dépéndances soi-même dans le Makefile
est fastidieux et probablement difficile à maintenir exact lors du développement du
code source. Pour compliquer les choses, le make sous Linux et Mac est le GNU make
tandis que celui de Windows qui vient avec Visual Studio est nmake. Ils ne sont pas
tout à fait compatibles, et comme de toutes façons les compilateurs sont différents et
n’utilisent pas les mêmes options, il faudrait faire au moins deux Makefile. Pour évi-
ter toute cette complexité, l’outil plus moderne CMake, une sorte de meta-make entre
en scène. Ses avantages sont :
— Un format plus simple et uniforme pour tous les OS de meta-Makefile appelé
CMakeLists.txt.
— Calcul automatique des dépendances.
— Possibilité (et c’est fortement conseillé) de placer les fichiers générés dans un dos-
sier autre (build directory) que celui des sources (source directory), de
manière à avoir une procédure de nettoyage très simple : simplement se débar-
rasser du build directory.
Le CMakeLists.txt pour l’exemple précédent est élémentaire :
find_package(Imagine REQUIRED)
add_executable(ImagineGraphicsTest test.cpp)
ImagineUseModules(ImagineGraphicsTest Graphics)
La première ligne indique qu’on a besoin d’utiliser Imagine++. Cela cherche un fi-
chier ImagineConfig.cmake qui contient entre autres la commande ImagineUseModules
(non standard dans CMake). La deuxième ligne indique que le programme à créer 6
s’appelle ImagineGraphicsTest(.exe sous Windows) et qu’il ne dépend que du
6. pour créer une bibliothèque (dynamique par défaut) à la place, il suffit de remplacer par
add_library
234
C. Compilateur, CMake, Linker, Qt. . . Au secours ! C.4. Utilisation d’un IDE
seul test.cpp. S’il y avait plusieurs .cpp, on les ajouterait à la ligne séparés par
des espaces. On peut aussi ajouter les .h, bien que ceux-ci ne soient pas compilés di-
rectement : ils seront juste visibles dans la partie headers si on demande à CMake de
créer un projet (voir les IDE). La dernière ligne indique que notre programme a besoin
de la bibliothèque Graphics d’Imagine++, ce qui indique les chemins des headers et
des bibliothèques. Le fait que cette bibliothèque dépende de Qt est automatiquement
ajouté. Un exemple typique d’utilisation de CMake en ligne de commande sour Linux
ou Mac :
mkdir Build ← Crée un dossier Build, le build directory
cd Build ← Va dans ce dossier
cmake .. ← Indique que le source directory est le parent (..)
make ← Il s’agit maintenant du make classique
Le lancement de cmake va créer un fichier CMakeCache.txt dans le build direc-
tory qui contient une liste de variables de CMake. Entre autres, on a CMAKE_BUILD_TYPE
qui indique le degré d’optimisation à appliquer. Le degré maximum est le mode Release,
tandis que le mode Debug est approprié pour un programme qu’on veut suivre ligne
à ligne. On peut parfaitement modifier une de ces variables 7 et relancer cmake. Le
lancement de cette commande génère le fichier Makefile pour nous, qui sert alors de
configuration au make classique.
À noter que la modification ultérieure du CMakeLists.txt, par exemple pour
ajouter des fichiers source dans la ligne add_executable, ne nécessite pas de relancer
explicitement cmake, car le Makefile généré retient que CMakeCache.txt est une
dépendance de CMakeLists.txt. Donc le fait de lancer make directement suffit à
relancer cmake avant d’effectuer le build normal.
Enfin, la force de CMake est qu’il connaît tous les IDE classiques (Visual Studio,
Eclipse, Code::Blocks, etc) et est capable de générer des projets pour ceux-ci (cf Fi-
gure C.2). Absents de cette liste sont Kdevelop (Linux) et surtout Qt Creator (toutes
plates-formes). En effet, ceux-ci gèrent eux-mêmes des projets CMake, donc on peut
lancer cmake depuis leur interface.
L’intérêt de tout ceci est que l’utilisateur peut choisir l’IDE qui lui convient le mieux
(ou aucun d’entre eux s’il préfère générer simplement des Makefiles) et qu’un seul
fichier de configuration CMakeLists.txt assûrera la portabilité du build sur toutes
les plates-formes. Ensuite, c’est au programmeur de coder en respectant la norme du
C++ pour un maximum de portabilité.
C.4 Utilisation d’un IDE

Le confort d’utilisation d’un IDE est notable : éditeur intégré, navigation facilitée
dans le code, build intégré, débugger, gestion de versions (git), analyseur mémoire
(vagrind sour Linux et Mac). . . On peut très bien modifier le CMakeLists.txt de-
puis l’éditeur intégré de l’IDE et ne pas relancer cmake soi-même par la suite : CMake
est suffisamment intelligent pour créer des projets qui savent quand il est nécessaire de
relancer cmake. Du coup, une fois le projet créé, on n’a pas besoin de sortir de l’IDE.
Néanmoins, pour que tous ces outils fonctionnent en harmonie, il faut que les
choses soient bien configurées. Par exemple, QtCreator doit savoir où trouver l’exé-
7. directement avec un éditeur de texte, ou alors avec les outils ccmake ou cmake-gui qui offrent
une interface graphique
235
C.4. Utilisation d’un IDE C. Compilateur, CMake, Linker, Qt. . . Au secours !
F IGURE C.2 – Création d’un projet avec choix de l’IDE et interaction avec les variables
de CMake stockées dans CMakeCache.txt grâce à cmake-gui. Notons que CMake
gère les différentes versions de Visual Studio, en 32 et 64 bits. Le compilateur MinGW
étant installé (il vient avec l’installeur de Qt), on peut aussi créer des Makefiles comme
sous Linux et Mac, sauf que le GNU make qui les interprète s’appelle mingw32-make
et non make.
cutable cmake, ainsi que le compilateur, débugger, etc. Enfin, il faut faire attention de
garder CMake comme système de build, et décliner, quand on crée un nouveau fichier
source, la proposition de l’IDE de l’intégrer au projet. Cela doit se faire au niveau de
CMake, donc modifier le CMakeLists.txt pour cela.
Pour Imagine++, il faut que la commande find_package(Imagine REQUIRED)
puisse trouver le fichier ImagineConfig.cmake. Pour cela, il faut l’aider en donnant
le dossier d’installation dans la variable Imagine_DIR.
Lorsque plus rien ne semble marcher, il est sage de créer un nouveau dossier de
build vierge et de travailler dans celui-ci. Cela peut s’avérer nécessaire après des chan-
gements majeurs dans un projet.
Enfin, notons que Qt n’est pas un IDE mais un ensemble de bibliothèques C++ multi-
plates-formes, utilisées par Imagine++. Il se trouve que l’IDE QtCreator utilise ces bi-
bliothèques Qt, et s’il a été installé en même temps que les bibliothèques Qt, il sait
directement où trouver ces dernières, ce qui aide pour un projet Imagine++.
236
D. Fiche de référence finale
Annexe D
Fiche de référence finale

Variables int i=m; // OK break;
— Définition : ... case 2:
int i; — Conversion : case 3:
int k,l,m; int i=int(x),j; ...;
float x=float(i)/j; break;
— Affectation :
default:
i=2; — Pile/Tas
...;
j=i; — Type énuméré : }
k=l=3; enum Dir{N,E,S,W};
— Initialisation : void avance(Dir d); — mx=(x>y)?x:y;
int n=5,o=n; — Variables statiques : Boucles
— Constantes : int f() {
const int s=12; static bool once=true; — do {
if (once) { ...
— Portée : } while(!ok);
int i; once=false;
// i=j; interdit! ... — int i=1;
int j=2; } while(i<=100) {
i=j; // OK! ... ...
if (j>1) { } i=i+1;
int k=3; }
Tests
j=k; // OK! — for(int i=1;i<=10;i++)
} — Comparaison :
== != < > <= >= ...
//i=k; interdit!
— Négation : ! — for(int i=1,j=10;j>i;
— Types : i=i+2,j=j-3)
int i=3; — Combinaisons : && ||
...
double x=12.3; — if (i==0) j=1;
char c=’A’; — for (int i=...)
— if (i==0) j=1; for (int j=...) {
string s="hop";
else j=2; //saute cas i==j
bool t=true;
float y=1.2f; if (i==j)
unsigned int j=4; — if (i==0) { continue;
signed char d=-128; j=1; ...
unsigned char d=25; k=2; }
complex<double> }
— for (int i=...) {
z(2,3); — bool t=(i==0); ...
if (t) if (t[i]==s){
— Variables globales : j=1; // quitte boucle
int n; — switch (i) { break;
const int m=12; case 1: }
void f() { ...; ...
n=10; // OK ...; }
238

Fonctions — Pile des appels t[i]=0;
— Définition : — Itératif/Récursif }
int plus(int a,int b){ — void init(int t[],
— Références constantes (pour
int c=a+b; int n) {
un passage rapide) :
return c; for(int i=0;i<n;i++)
void f(const obj& x){
} t[i]=0;
...
void affiche(int a) { }
}
cout << a << endl;
void g(const obj& x){ — Taille variable :
}
f(x); // OK int* t=new int[n];
— Déclaration : } ...
int plus(int a,int b); delete[] t;
— Valeurs par défaut :
— Retour : void f(int a,int b=0); — En paramètre (suite) :
int signe(double x) { void g() {
if (x<0) — void f(int* t,int n){
f(12); // f(12,0); t[i]=...
return -1; f(10,2);// f(10,2);
if (x>0) }
}
return 1; void f(int a,int b) { — void alloue(int*& t){
return 0; // ... t=new int[n];
} } }
void afficher(int x, — 2D :
int y) { — Inline (appel rapide) :
inline double int A[2][3];
if (x<0 || y<0) A[i][j]=...;
return; sqr(double x) {
return x*x; int A[2][3]=
if (x>=w || y>=h) {{1,2,3},{4,5,6}};
return; }
... void f(int A[2][2]);
DrawPoint(x,y,RED);
} double y=sqr(z-3); — 2D dans 1D :
— Référence en retour : int A[2*3];
— Appel :
int i; // Var. globale A[i+2*j]=...;
int f(int a) { ... }
int g() { ... } int& f() { — Taille variable (suite) :
... return i; int *t,*s,n;
int i=f(2),j=g(); } — En paramètre (fin) :
— Références : ... void f(const int* t,
void swap(int& a, f()=3; // i=3! int n) {
int& b){ Tableaux ...
int tmp=a; s+=t[i]; // OK
a=b;b=tmp; — Définition : ...
} — double x[5],y[5]; t[i]=...; // NON!
... for(int i=0;i<5;i++) }
int x=3,y=2; y[i]=2*x[i];
swap(x,y); Structures
— const int n=5;
— Surcharge : int i[n],j[2*n]; — struct Point {
int hasard(int n); double x,y;
int hasard(int a, Color c;
int t[4]={1,2,3,4};
int b); };
string s[2]={"ab","c"};
double hasard(); ...
— Affectation : Point a;
— Opérateurs :
int s[3]={1,2,3},t[3]; a.x=2.3; a.y=3.4;
vect operator+(
for (int i=0;i<3;i++) a.c=Red;
vect A,vect B) {
t[i]=s[i]; Point b={1,2.5,Blue};
...
} — En paramètre : — Une structure est un objet en-
... — void init(int t[4]) { tièrement public (→ cf ob-
vect C=A+B; for(int i=0;i<4;i++) jets !)
239

Objets void g(const obj& x){ double *x;
— struct obj { x.f(); // OK public:
int x; // champ } double& operator()
int f(); // méthode — Constructeur : (int i,int j){
int g(int y); class point { assert(i>=0 ...);
}; int x,y; return x[i+M*j];
int obj::f() { public: }
int i=g(3); // mon g point(int X,int Y); double operator()
int j=x+i; // mon x }; (int i,int j)const{
return j; point::point(int X, assert(i>=0 ...);
} int Y){ return x[i+M*j];
... x=X; }
int main() { y=Y; ...
obj a; }
Compilation séparée
a.x=3; ...
int i=a.f(); point a(2,3); — #include "vect.h", aussi
— class obj { — Constructeur vide : dans vect.cpp
int x,y; obj::obj() { — Fonctions : déclarations dans
void a_moi(); ... le .h, définitions dans le
public: } .cpp
int z; ... — Types : définitions dans le .h
void pour_tous(); obj a;
void autre(obj A); — Ne déclarer dans le .h que les
— Objets temporaires :
}; fonctions utiles.
vec vec::operator+(
void obj::a_moi() { vec b) { — #pragma once au début du
x=..; // OK return vec(x+b.x, fichier.
..=y; // OK y+b.y); — Ne pas trop découper. . .
z=..; // OK }
} ... STL
void obj::pour_tous(){ c=vec(1,2)
x=..; // OK — min,max,...
+f(vec(2,3));
a_moi(); // OK — complex<double> z;
— Destructeur :
}
obj::~obj() { — pair<int,string> p;
void autre(obj A) {
... p.first=2;
x=A.x; // OK
} p.second="hop";
A.a_moi(); // OK
} — Constructeur de copie : — #include<list>
... obj::obj(const obj& o){ using namespace std;
int main() { ... ...
obj A,B; } list<int> l;
A.x=..; //NON Utilisé par : l.push_front(1);
A.z=..; //OK - obj b(a); ...
A.a_moi(); //NON - obj b=a;
— if(l.find(3)!=l.end())
A.pour_tous(); //OK //mieux que obj b;b=a;
...
A.autre(B); //OK - paramètres des fonctions
- valeur de retour — list<int>::
— class obj {
— Affectation : const_iterator it;
obj operator+(obj B);
obj& obj::operator=( for (it=l.begin();
};
const obj&o){ it!=l.end();it++)
...
... s+= *it;
int main() {
obj A,B,C; return *this; — list<int>::iterator it
C=A+B; } for (it=l.begin();
// C=A.operator+(B) — Objets avec allocation dyna- it!=l.end();it++)
— Méthodes constantes : mique automatique : cf sec- if (*it==2)
void obj::f() const{ tion 10.11 * it=4;
... — Accesseurs : — stack, queue, heap,
} class mat { map, set, vector...
240

Entrées/Sorties const point&p){ };
— #include <iostream> f<<p.x<<’ ’<< p.y; ...
using namespace std; return f; hop<int,string> A;
... } ...
cout <<"I="<<i<<endl; istream& operator>>( — Entiers :
cin >> i >> j; istream& f,point& p){ template <int N>
f>>p.x>>p.y; class hop {
— #include <fstream>
return f; ..
} };
ofstream f("hop.txt");
f << 1 << ’ ’ << 2.3; Template ...
f.close(); hop<3> A;
— Fonctions :
ifstream g("hop.txt"); ...
// A mettre dans le
if (!g.is_open()) { // fichier qui utilise Conseils
return 1; // ou dans un .h
} — Nettoyer en quittant.
template <typename T>
int i; T maxi(T a,T b) { — Erreurs et warnings : cliquer.
double x; ... — Indenter.
g >> i >> x; }
g.close(); — Ne pas laisser de warning.
...
— do { // Le type est trouvé — Utiliser le debuggeur.
... // tout seul! — Faire des fonctions.
} while (!(g.eof()); maxi(1,2); //int — Tableaux : pas pour transcrire
— ofstream f; maxi(.2,.3); //double une formule mathématique !
f.open("hop.txt"); maxi("a","c");//string
— double x[10],y; — Faire des fichiers séparés.
ofstream f("hop.bin", — Objets :
ios::binary); template <typename T> — Le .h doit suffire à l’utilisa-
f.write((const char*)x, class paire { teur (qui ne doit pas regarder
10*sizeof(double)); T x[2]; le .cpp)
f.write((const char*)&y, public: — Ne pas abuser du récursif.
sizeof(double)); paire() {}
paire(T a,T b) { — Ne pas oublier delete.
f.close();
ifstream g("hop.bin", x[0]=a;x[1]=b; — Compiler régulièrement.
ios::binary); } — #include <cassert>
g.read((char*)x, T add()const; ...
10*sizeof(double)); }; assert(x!=0);
g.read((const char*)&y, ... y=1/x;
sizeof(double)); template <typename T>
g.close(); T paire<T>::add()const{ — Faire des objets.
return x[0]+x[1]; — Ne pas toujours faire des ob-
— string s; } jets !
ifstream f(s.c_str()); ... — Penser interface / implémen-
— #include <sstream> // Le type doit être tation / utilisation.
using namespace std; // précisé!
stringstream f; paire<int> a(1,2); Clavier
// Chaîne vers entier int s=a.somme(); — Debug : F5
f << s; f >> i; paire<double> b;
// Entier vers chaîne ... — Step over : F10
f.clear(); — Multiples : — Step inside : F11
f << i; f >> s; ⇔ template <typename T, — Indent : Ctrl+A,Ctrl+I
s = std::to_string(i); typename S>
— ostream& operator<<( class hop { — Step out : Maj+F11
ostream& f, ... — Gest. tâches : Ctrl+Maj+Ech
241

Divers exemples : — int *t,s;// s est int
set(i,1) : i|=(1<<n) // non int*
— i++;
reset(i,1) : i&=~(1<<n) t=new int[n];
i--;
test(i,1) : if (i&(1<<n)) s=new int[n];// NON!
i-=2;
flip(i,1) : i^=(1<<n) — class vec {
j+=3;
int x,y;
— j=i%n; // Modulo Erreurs fréquentes
public:
— #include <cstdlib> — Pas de définition de fonction ...
... dans une fonction ! };
i=rand()%n; — int q=r=4; // NON! ...
x=rand()/ — if (i=2) // NON! vec a={2,3}; // NON
double(RAND_MAX); if i==2 // NON! — vec v=vec(1,2);//NON
— #include <ctime> if (i==2) then // NON! vec v(1,2); // OUI
// Un seul appel — for(int i=0,i<100,i++) — obj* t=new obj[n];
srand((unsigned int) // NON! delete t; // manque []
time(0)); — int f() {...} — //NON!
— #include <cmath> int i=f; // NON! void f(int a=2,int b);
double sqrt(double x); — double x=1/3; // NON! — void f(int a,int b=0);
double cos(double x); int i,j; void f(int a);// NON!
double sin(double x); x=i/j; // NON!
double acos(double x); x=double(i/j); //NON! — Ne pas tout mettre inline !
— double x[10],y[10]; — int f() {
— #include <string>
for(int i=1;i<=10;i++) ...
y[i]=2*x[i];//NON }
string s="hop";
f()=3; // HORREUR!
char c=s[0]; — int n=5;
int l=s.size(); int t[n]; // NON — int& f() {
if (s1==s1) ... int i;
— int f()[4] { // NON!
if (s1!=s2) ... return i;
int t[4];
if (s1<s2) ... }
...
size_t i=s.find(’h’), f()=3; // NON!
return t; // NON!
j=s.find(’h’,3); } — if (i>0 & i<n) // NON
k=s.find("hop"); int t[4]; t=f(); if (i<0 | i>n) // NON
l=s.find("hop",3);
— int s[3]={1,2,3},t[3]; — if (...) {
a="comment";
t=s; // NON! ...
b="ça va?";
— int t[2]; if (...)
txt=a+" "+b;
t={1,2}; // NON! break; // Non,
s1="un deux trois";
// boucles seulement
s2=string(s1,3,4); — struct Point {
}
getline(cin,s); double x,y;
getline(cin,s,’:’); } // NON! — for (i ...)
const char *t=s.c_str();— Point a; for (j ...) {
...
— #include <ctime> a={1,2}; // NON!
if (...)
s=double(clock()) — #include "tp.cpp"//NON break;//NON, quitte
/CLOCKS_PER_SEC; — int f(int t[][]);//NON // juste boucle j
— #include <cmath> int t[2,3]; // NON!
— int i;
double pi=M_PI; t[i,j]=...; // NON!
double x;
— Opérateurs binaires — int* t; j=max(i,0);//OK
t[1]=...; // NON! y=max(x,0);//NON!
and : a&b
or : a|b — int* t=new int[2]; // 0.0 et non 0: max
xor : a^b int* s=new int[2]; // est un template STL
right shift : a>>n s=t; // On perd s!
delete[] t; Imagine++
left shift : a<<n
complement : ~a delete[] s;//Déjà fait — Voir documentation. . .
242

Programmer

Transféré par

Droits d'auteur :

Formats disponibles

Programmer

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Programmer

Transféré par

Droits d'auteur :

Formats disponibles

LA PROGRAMMATION POUR. . .

Cours de l’École des Ponts ParisTech - 2020/2021

— "Cet ordinateur ne fait pas du tout ce que je veux !"

Table des matières

7.4 Le tas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

8 Allocation dynamique 107

9 Premiers objets 121

10 Constructeurs et Destructeurs 137

10.6.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

11 Chaînes de caractères, fichiers 159

12 Fonctions et classes paramétrées (templates) 175

A Travaux Pratiques 193

C Compilateur, CMake, Linker, Qt. . . Au secours ! 231

D Fiche de référence finale 237

Note : Ce premier chapitre maladroit correspond à l’état d’esprit dans lequel ce

— Le Maître Programmeur 1 : "Rassure-toi ! Les ordinateurs sont stupides ! Program-

Oublions là ce dialogue aussi caricatural que maladroit. Il montre pourtant claire-

En conclusion, collégiens ou ingénieurs, débutants ou passionnés, tous les élèves sont

1.1 Pourquoi savoir programmer ?

1.2 Comment apprendre ?

1.2.2 Choix de l’environnement

15. Les opérateurs par exemple.

1.2.3 Principes et conseils

5. Debugger. Souvent, la connaissance du debuggeur (l’outil pour rechercher les

passer à notre premier programme !

Si l’on en croit de nombreux manuels de programmation, un premier programme

Ouf ! Que de termes en italique. Que de concepts à essayer d’expliquer ! Et pour

on ne programme pas convenablement sans comprendre ce que l’ordinateur

Stop ! Stop ! Stop ! Faux départ ! On reprend le :

Chapitre 2 (deuxième essai)

00415A61 mov eax,dword ptr [a] // mettre dans le registre eax

Ce programme est désigné comme du Code Machine. Le nombre au début de chaque

Une fois traduit en langage machine pour un micro-processeur donné, un

00415A61 8B 45 F8 mov eax,dword ptr [a]

00415A6A 6B C9 03 imul ecx,ecx,3

car "lea edx,[eax+ecx*3]" n’existe pas !

adresse mémoire contenu représente

La mémoire ne sert pas uniquement à stocker la suite d’instructions à exécuter mais

adresse mémoire contenu représente

où les octets a1 , . . . , a4 combinés donnent l’entier a sur 32 bits. Certains processeurs

Tout comme pour les instructions, un nombre stocké par un micro-

2.1.3 Autres Composants

Faire travailler le micro-processeur avec le disque dur est BEAUCOUP plus

Au début, les moyens de stockages étaient mécaniques : cartes ou bandes perfo-

2.2 Système d’exploitation

En résumé, la production du fichier exécutable se fait de la façon suivante :

42. même s’il est parfois pré-traité pour accélérer l’exécution.

2.4 L’environnement de programmation

2.4.1 Noms de fichiers

46. souvent appelé IDE, Integrated Development Environment.

2.5 Le minimum indispensable

F IGURE 2.1 – QtCreator après compilation du programme de test

En coulisses, QtCreator a lancé le programme CMake et on voit les messages d’infor-

2.5.2 Un peu plus. . .

F IGURE 2.2 – QtCreator configuré pour compiler en mode Debug.

1. Sous Windows, toujours travailler en local et sauvegarder sur le

Ctrl+A, Ctrl+I (QtCreator) = Indent selection

F IGURE 2.3 – Ce qu’il faut retenir du TP 1

Fiche de référence (1/1)

Parés à expérimenter au fur et à mesure avec notre environnement de programmation, il est