Penser en C++ vol.1 et 2

8/18/2019 Penser en C++ vol.1 et 2

1/436

Penser en C++

Volume 1

Par Bruce Eckel - bigboomshakala (traducteur)

Date de publication : 27 août 2008

Dernière mise à jour : 27 août 2008

Ce cours est une traduction du livre Thinking in C++ de Bruce Eckel, dont l'original estdisponible ici : http://bruce-eckel.developpez.com/livres/cpp/ticpp/v1/.

http://bruce-eckel.developpez.com/livres/cpp/ticpp/v1/http://www.developpez.net/forums/u34797/bigboomshakala/http://bruce-eckel.developpez.com/http://bruce-eckel.developpez.com/http://www.developpez.com/


2/436

Penser en C++ par Bruce Eckel

- 2 -

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de

présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2005 Bruce Eckel. Aucune reproduction,

même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation

expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

htt ://bruce-eckel develo ez com/livres/c /traduction/tic 2vol1/

0 - Préface................................................................................................................................................................. 100.1 - Quoi de neuf dans cette seconde édition ?................................................................................................ 10

0.1.1 - Qu'y a-t-il dans le Volume 2 de ce livre ?...........................................................................................100.1.2 - Comment récupérer le Volume 2 ?.....................................................................................................10

0.2 - Prérequis......................................................................................................................................................110.3 - Apprendre le C++........................................................................................................................................ 11

0.4 - Buts..............................................................................................................................................................120.5 - Chapitr es......................................................................................................................................................120.6 - Exercices......................................................................................................................................................15

0.6.1 - Solutions des exercices...................................................................................................................... 150.7 - Le Code Source.......................................................................................................................................... 150.8 - Nor mes du langage..................................................................................................................................... 16

0.8.1 - Support du langage.............................................................................................................................170.9 - Le CD ROM du livre....................................................................................................................................170.10 - CD ROMs, conférences, et consultations................................................................................................. 170.11 - Erreur s........................................................................................................................................................170.12 - A propos de la couverture.........................................................................................................................180.13 - Conception et production du livre............................................................................................................. 18

0.14 - Remerciements.......................................................................................................................................... 191 - Introduction sur les Objets...................................................................................................................................201.1 - Les bienfaits de l'abstraction.......................................................................................................................201.2 - Un objet dispose d'une interface.................................................................................................................211.3 - L'implémentation cachée............................................................................................................................. 231.4 - Réutilisation de l'implémentation................................................................................................................. 241.5 - Héritage : réutilisation de l'interface............................................................................................................ 24

1.5.1 - Les relations est-un vs. est-comme-un...............................................................................................271.6 - Polymorphisme : des objets inter changeables............................................................................................281.7 - Créer et détruire les objets..........................................................................................................................311.8 - Traitement des exceptions : gérer les erreurs.............................................................................................311.9 - Analyse et conception................................................................................................................................. 32

1.9.1 - Phase 0 : Faire un plan...................................................................................................................... 33

1.9.2 - Phase 1 : Que construit-on ?.............................................................................................................. 341.9.3 - Phase 2 : Comment allons-nous le construire ?................................................................................. 361.9.4 - Phase 3 : Construire le coeur du système......................................................................................... 381.9.5 - Phase 4 : Itérer sur les cas d'utilisation..............................................................................................391.9.6 - Phase 5 : Evolution............................................................................................................................. 391.9.7 - Les plans sont payants.......................................................................................................................40

1.10 - Extreme programming............................................................................................................................... 401.10.1 - Commencer par écrire les tests........................................................................................................411.10.2 - Programmation en binôme................................................................................................................42

1.11 - Les raisons du succès du C++..................................................................................................................421.11.1 - Un meilleur C.....................................................................................................................................431.11.2 - Vous êtes déjà sur la courbe d'appr entissage.................................................................................. 43

1.11.3 - Efficacité.............................................................................................................................................431.11.4 - Les systèmes sont plus f aciles à exprimer et à comprendre............................................................ 441.11.5 - Puissance maximale grâce aux bibliothèques.................................................................................. 441.11.6 - Réutilisation des sources avec les templates................................................................................... 441.11.7 - Traitement des erreurs...................................................................................................................... 441.11.8 - Mise en oeuvre de gros projets........................................................................................................ 44

1.12 - Str atégies de transition..............................................................................................................................451.12.1 - Les grandes lignes............................................................................................................................451.12.2 - Ecueils de la gestion.........................................................................................................................46

1.13 - Résumé......................................................................................................................................................472 - Construir e et utiliser les objets............................................................................................................................ 48

2.1 - Le processus de traduction du langage......................................................................................................482.1.1 - Les interpréteurs................................................................................................................................. 492.1.2 - Les compilateurs................................................................................................................................. 492.1.3 - Le processus de compilation.............................................................................................................. 50

http://bruce-eckel.developpez.com/livres/cpp/traduction/ticpp2vol1/http://bruce-eckel.developpez.com/http://www.developpez.com/


3/436


- 3 -






2.2 - Outils de compilation séparée.....................................................................................................................512.2.1 - Déclarations vs. définitions................................................................................................................. 512.2.2 - Edition des liens..................................................................................................................................552.2.3 - Utilisation des bibliothèques................................................................................................................55

2.3 - Votre premier programme C++....................................................................................................................562.3.1 - Utilisation de la classe iostream......................................................................................................... 56

2.3.2 - Espaces de noms............................................................................................................................... 572.3.3 - Pr incipes fondamentaux de structure de programme.........................................................................582.3.4 - "Bonjour tout le monde !".................................................................................................................... 592.3.5 - Lancer le compilateur..........................................................................................................................59

2.4 - Plus sur les flux d'entrée-sortie...................................................................................................................602.4.1 - Concaténation de tableaux de caractères.......................................................................................... 602.4.2 - Lire les entrées................................................................................................................................... 612.4.3 - Appeler d'autres programmes.............................................................................................................61

2.5 - Introduction aux chaînes de car actères...................................................................................................... 612.6 - Lire et écrire des fichiers.............................................................................................................................622.7 - Intoduction à la classe vector......................................................................................................................642.8 - Résumé........................................................................................................................................................67

2.9 - Exercices......................................................................................................................................................673 - Le C de C++........................................................................................................................................................683.1 - Création de fonctions...................................................................................................................................68

3.1.1 - Valeurs de retour des fonctions.......................................................................................................... 693.1.2 - Utilisation de la bibliothèque de fonctions du C..................................................................................703.1.3 - Cr éer vos propres bibliothèques avec le bibliothécaire...................................................................... 70

3.2 - Contrôle de l'exécution................................................................................................................................ 713.2.1 - Vr ai et faux..........................................................................................................................................713.2.2 - if-else................................................................................................................................................... 713.2.3 - while.....................................................................................................................................................723.2.4 - do-while............................................................................................................................................... 733.2.5 - for.........................................................................................................................................................733.2.6 - Les mots clé break et continue...........................................................................................................74

3.2.7 - switch...................................................................................................................................................753.2.8 - Du bon et du mauvais usage du goto................................................................................................ 763.2.9 - Récursion.............................................................................................................................................76

3.3 - Introduction aux operateurs.........................................................................................................................773.3.1 - Pr iorité................................................................................................................................................. 773.3.2 - Auto incrémentation et décrémentation.............................................................................................. 77

3.4 - Introduction aux types de données............................................................................................................. 783.4.1 - Types intégrés de base.......................................................................................................................783.4.2 - bool, true, & false................................................................................................................................793.4.3 - Spécificateurs...................................................................................................................................... 793.4.4 - Introduction aux pointeurs...................................................................................................................813.4.5 - Modification d'objets extérieurs...........................................................................................................83

3.4.6 - Introduction aux références en C++................................................................................................... 843.4.7 - Pointeurs et références comme modificateurs....................................................................................853.5 - Portée des variables....................................................................................................................................873.5-bis - Définir des var iables "à la volée".......................................................................................................... 873.6 - Définir l'allocation mémoire..........................................................................................................................89

3.6.1 - Variables globales............................................................................................................................... 893.6.2 - Variables locales..................................................................................................................................903.6.3 - static.................................................................................................................................................... 903.6.4 - extern...................................................................................................................................................913.6.5 - Constantes...........................................................................................................................................923.6.6 - volatile..................................................................................................................................................93

3.7 - Operateurs et leurs usages.........................................................................................................................943.7.1 - L'affectation..........................................................................................................................................943.7.2 - Opérateurs mathématiques.................................................................................................................943.7.3 - Opérateurs relationnels....................................................................................................................... 95



4/436


- 4 -






3.7.4 - Opérateurs logiques............................................................................................................................953.7.5 - Opérateurs bit à bit............................................................................................................................. 963.7.6 - Opérateurs de décalage......................................................................................................................963.7.7 - Opérateurs unaires..............................................................................................................................983.7.8 - L'opérateur ternaire............................................................................................................................. 993.7.9 - L'opérateur virgule...............................................................................................................................99

3.7.10 - Piège classique quand on utilise les opérateurs............................................................................ 1003.7.11 - Opérateurs de transtypage..............................................................................................................1003.7.12 - Transtypage C++ explicite...............................................................................................................1013.7.13 - sizeof Un opérateur par lui même............................................................................................... 1043.7.14 - Le mot clef asm.............................................................................................................................. 1043.7.15 - Opérateurs explicites.......................................................................................................................105

3.8 - Création de type composite...................................................................................................................... 1053.8.1 - Alias de noms avec typedef..............................................................................................................1053.8.2 - Combiner des variables avec des struct...........................................................................................1063.8.3 - Eclaircir les programmes avec des enum.........................................................................................1083.8.4 - Economiser de la mémoire avec union............................................................................................ 1093.8.5 - Tableaux............................................................................................................................................ 110

3.9 - Conseils de déboguage.............................................................................................................................1173.9.1 - Dr apeaux de déboguage...................................................................................................................1173.9.2 - Tr ansformer des variables et des expressions en chaînes de caractère..........................................1183.9.3 - la macro C assert( ).......................................................................................................................... 119

3.10 - Adresses de fonctions............................................................................................................................. 1193.10.1 - Définir un pointeur de fonction........................................................................................................1203.10.2 - Déclarations complexes & définitions............................................................................................. 1203.10.3 - Utiliser un pointeur de fonction....................................................................................................... 1213.10.4 - Tableau de pointeurs de fonction....................................................................................................121

3.11 - Make: gestion de la compilation séparée................................................................................................1223.11.1 - Les actions du Make....................................................................................................................... 1233.11.2 - Les makefiles de ce livre................................................................................................................ 1253.11.3 - Un exemple de makefile..................................................................................................................125

3.12 - Résumé....................................................................................................................................................1263.13 - Exercices..................................................................................................................................................127

4 - Abstraction des données................................................................................................................................... 1284.1 - Une petite bibliothèque dans le style C.................................................................................................... 129

4.1.1 - Allocation dynamique de mémoire....................................................................................................1324.1.2 - Mauvaises conjectures......................................................................................................................134

4.2 - Qu'est-ce qui ne va pas?.......................................................................................................................... 1354.3 - L'objet de base.......................................................................................................................................... 1364.4 - Qu'est-ce qu'un objet?...............................................................................................................................1404.5 - Typage de données abstraites.................................................................................................................. 1404.6 - Détails sur les objest.................................................................................................................................1414.7 - L'étiquette d'un fichier d'en-tête.................................................................................................................142

4.7.1 - L'importance des fichiers d'en-tête................................................................................................... 1424.7.2 - Le problème des déclarations multiples........................................................................................... 1434.7.3 - Les directives define, ifdef et endif du préprocesseur................................................................ 1444.7.4 - Un standard pour les fichiers d'en-tête.............................................................................................1454.7.5 - Les espaces de nommage dans les fichiers d'en-tête......................................................................1454.7.6 - Utiliser des fichiers d'en-tête dans des projets................................................................................. 146

4.8 - Structures imbriquées................................................................................................................................1464.8.1 - Résolution de portée globale............................................................................................................ 148

4.9 - Résumé......................................................................................................................................................1494.10 - Exercices..................................................................................................................................................149

5 - Cacher l'implémentation.....................................................................................................................................1515.1 - Fixer des limites........................................................................................................................................ 1515.2 - Le contrôle d'accès en C++...................................................................................................................... 151

5.2.1 - pr otected............................................................................................................................................1535.3 - L'amitié.......................................................................................................................................................153



5/436


- 5 -






5.3.1 - Amis emboîtés...................................................................................................................................1545.3.2 - Est-ce pur ?.......................................................................................................................................156

5.4 - Organisation physique d'un objet..............................................................................................................1565.5 - La classe....................................................................................................................................................157

5.5.1 - Modifier Stash pour employer le contrôle d'accès............................................................................1595.5.2 - Modifier Stack pour employer le contrôle d'accès............................................................................ 159

5.6 - Manipuler les classes................................................................................................................................ 1605.6.1 - Dissimuler l'implémentation...............................................................................................................1605.6.2 - Réduire la recompilation................................................................................................................... 160

5.7 - Résumé......................................................................................................................................................1625.8 - Exercices....................................................................................................................................................162

6 - Initialisation & Nettoyage................................................................................................................................... 1636.1 - Initialisation garantie avec le constructeur................................................................................................ 1646.2 - Gar antir le nettoyage avec le destructeur.................................................................................................1656.3 - Elimination de la définition de bloc........................................................................................................... 167

6.3.1 - les boucles........................................................................................................................................ 1686.3.2 - Allocation de mémoire.......................................................................................................................168

6.4 - Stash avec constructueur et destructeur...................................................................................................169

6.5 - Stack avec des constructeurs & des destructeurs.................................................................................... 1716.6 - Initialisation d'aggrégat.............................................................................................................................. 1736.7 - Les constructeurs par défaut.....................................................................................................................1756.8 - Résumé......................................................................................................................................................1766.9 - Exercices....................................................................................................................................................176

7 - Fonctions surchargée et arguments par défaut.................................................................................................1777.1 - Plus sur les décorations de nom...............................................................................................................178

7.1.1 - Valeur de retour surchar gée :........................................................................................................... 1787.1.2 - Edition de liens sécurisée................................................................................................................. 179

7.2 - Exemple de surchargement.......................................................................................................................1797.3 - unions.........................................................................................................................................................1827.4 - Les arguments par défaut......................................................................................................................... 184

7.4.1 - Paramètre fictif.................................................................................................................................. 185

7.5 - Choix entre surcharge et arguments par défaut....................................................................................... 1857.6 - Résumé......................................................................................................................................................1887.7 - Exercices....................................................................................................................................................189

8 - Constantes......................................................................................................................................................... 1898.1 - Substitution de valeurs.............................................................................................................................. 1908.2 - Les pointeurs............................................................................................................................................. 193

8.2.1 - Pointeur vers const........................................................................................................................... 1948.2.2 - Pointeur const................................................................................................................................... 1948.2.3 - Assignation et vérification de type.................................................................................................... 195

8.3 - Arguments d'une fonction & valeurs retournées....................................................................................... 1968.3.1 - Passer par valeur const.................................................................................................................... 1968.3.2 - Retour par valeur const.................................................................................................................... 196

8.3.3 - Passer et retourner des adresses.....................................................................................................1988.4 - Classes...................................................................................................................................................... 2008.4.1 - const dans les classes......................................................................................................................2018.4.2 - Constantes de compilation dans les classes....................................................................................2038.4.3 - ob jets cont & fonctions membres......................................................................................................205

8.5 - volatile........................................................................................................................................................2088.6 - Résumé......................................................................................................................................................2098.7 - Exercices....................................................................................................................................................209

9 - Fonctions inlines................................................................................................................................................ 2109.1 - Ecueils du préprocesseurs........................................................................................................................ 211

9.1.1 - Les macros et l'accès....................................................................................................................... 2139.2 - Fonctions inline..........................................................................................................................................214

9.2.1 - Les inline dans les classes...............................................................................................................2149.2.2 - Fonctions d'accès..............................................................................................................................215

9.3 - Stash & Stack avec les inlines..................................................................................................................218



6/436


- 6 -






9.4 - Les inline & le compilateur........................................................................................................................2219.4.1 - Limitations..........................................................................................................................................2229.4.2 - Déclarations aval...............................................................................................................................2229.4.3 - Activités cachées dans les constructeurs et les destructeurs...........................................................223

9.5 - Réduire le fouillis.......................................................................................................................................2249.6 - Caractéristiques supplémentaires du préprocesseur................................................................................ 224

9.6.1 - Collage de jeton................................................................................................................................ 2259.7 - Vérification d'erreurs améliorée.................................................................................................................2259.8 - Résumé......................................................................................................................................................2279.9 - Exercices....................................................................................................................................................228

10 - Contrôle du nom.............................................................................................................................................. 22910.1 - Eléments statiques issus du C................................................................................................................229

10.1.1 - Variables statiques à l'intérieur des fonctions................................................................................. 22910.1.2 - Contrôle de l'édition de liens...........................................................................................................23210.1.3 - Autre spécificateurs de classe de stockage....................................................................................234

10.2 - Les namespaces......................................................................................................................................23410.2.1 - Créer un espace de nommage....................................................................................................... 23410.2.2 - Utiliser un espace de nommage..................................................................................................... 236

10.2.3 - L'utilisation des espace de nommage.............................................................................................23910.3 - Membres statiques en C++..................................................................................................................... 24010.3.1 - Définir le stockage pour les données membres statiques.............................................................. 24010.3.2 - Classes imbriquées et locales........................................................................................................ 24310.3.3 - Fonctions membres statiques......................................................................................................... 243

10.4 - Dépendance de l'initialisation statique.................................................................................................... 24510.4.1 - Que faire..........................................................................................................................................246

10.5 - Spécification alternative des conventions de liens..................................................................................25110.6 - Sommaire.................................................................................................................................................25110.7 - Exercices..................................................................................................................................................252

11 - Références & le constructeur de copie............................................................................................................25411.1 - Les pointeurs en C++.............................................................................................................................. 25411.2 - Les références en C++............................................................................................................................255

11.2.1 - Les références dans les fonctions.................................................................................................. 25511.2.2 - Indications sur le passage d'arguments..........................................................................................257

11.3 - Le constructeur par recopie.....................................................................................................................25711.3.1 - Passer & renvoyer par valeur......................................................................................................... 25711.3.2 - Construction par recopie................................................................................................................. 26111.3.3 - Constructeur par recopie par défaut............................................................................................... 26511.3.4 - Alternatives à la construction par recopie.......................................................................................266

11.4 - Pointeurs sur membre............................................................................................................................. 26711.4.1 - Fonctions......................................................................................................................................... 269

11.5 - Résumé.................................................................................................................................................... 27111.6 - Exercices..................................................................................................................................................271

12 - Surcharges d'opérateurs.................................................................................................................................. 273

12.1 - Soyez avertis et rassurés........................................................................................................................27312.2 - Syntaxe.................................................................................................................................................... 27412.3 - Opérateurs surchargeables..................................................................................................................... 275

12.3.1 - Opérateurs unaires..........................................................................................................................27512.3.2 - Opérateurs binaires.........................................................................................................................27812.3.3 - Arguments & valeurs de retour.......................................................................................................28512.3.4 - opérateurs inhabituels..................................................................................................................... 28712.3.5 - Opérateurs que vous ne pouvez pas surcharger........................................................................... 292

12.4 - Opérateurs non membres........................................................................................................................29212.4.1 - Conseils élémentaires..................................................................................................................... 294

12.5 - Surcharge de l'affectation........................................................................................................................29412.5.1 - Comportement de operator=...........................................................................................................295

12.6 - Conversion de type automatique.............................................................................................................30112.6.1 - Conversion par constructeur........................................................................................................... 30212.6.2 - Conversion par opérateur............................................................................................................... 303



7/436


- 7 -






12.6.3 - Exemple de conversion de type......................................................................................................30412.6.4 - Les pièges de la conversion de type automatique......................................................................... 305


13 - Création d'Objets Dynamiques........................................................................................................................ 30913.1 - Création d'objets......................................................................................................................................309

13.1.1 - L'approche du C au tas.................................................................................................................. 31013.1.2 - l'operateur new................................................................................................................................31113.1.3 - l'opérateur delete.............................................................................................................................31213.1.4 - Un exemple simple..........................................................................................................................31213.1.5 - Le surcoût du gestionnaire de mémoire......................................................................................... 313

13.2 - Exemples précédents revus.................................................................................................................... 31313.2.1 - detruire un void* est probablement une erreur...............................................................................31313.2.2 - La responsabilité du nettoyage avec les pointeurs.........................................................................31413.2.3 - Stash pour des pointeurs................................................................................................................315

13.3 - new & delete pour les tableaux...............................................................................................................31813.3.1 - Rendre un pointeur plus semblable à un tableau...........................................................................319

13.4 - Manquer d'espace de stockage.............................................................................................................. 319

13.5 - Surcharger new & delete.........................................................................................................................32013.5.1 - La surcharge globale de new & delete...........................................................................................32113.5.2 - Surcharger new & delete pour une classe......................................................................................32213.5.3 - Surcharger new & delete pour les tableaux....................................................................................32413.5.4 - Appels au constructeur................................................................................................................... 32513.5.5 - new & delete de placement............................................................................................................ 326


14 - Héritage & composition....................................................................................................................................32914.1 - Syntaxe de la composition...................................................................................................................... 32914.2 - Syntaxe de l'héritage............................................................................................................................... 33014.3 - La liste d'initialisation du construteur.......................................................................................................332

14.3.1 - Initialisation d'un objet membre.......................................................................................................332

14.3.2 - Types prédéfinis dans la liste d'initialisation................................................................................... 33214.4 - Combiner composition & héritage........................................................................................................... 333

14.4.1 - Ordre des appels des constructeurs & et des destructeurs............................................................33414.5 - Masquage de nom...................................................................................................................................33514.6 - Fonctions qui ne s'héritent pas automatiquement...................................................................................338

14.6.1 - Héritage et fonctions membres statiques........................................................................................34114.7 - Choisir entre composition et héritage......................................................................................................341

14.7.1 - Sous-typer....................................................................................................................................... 34214.7.2 - héritage privé...................................................................................................................................344

14.8 - protected.................................................................................................................................................. 34414.8.1 - héritage protégé.............................................................................................................................. 345

14.9 - Surcharge d'opérateur & héritage........................................................................................................... 345

14.10 - Héritage multiple....................................................................................................................................34714.11 - Développement incrémental.................................................................................................................. 34714.12 - Transtypage ascendant......................................................................................................................... 347

14.12.1 - Pourquoi "ascendant" ?.................................................................................................................34814.12.2 - Le transtypage ascendant et le constructeur de copie................................................................. 34814.12.3 - Composition vs. héritage (révisé)................................................................................................. 35014.12.4 - Transtypage ascendant de pointeur & de reference.....................................................................35114.12.5 - Une crise....................................................................................................................................... 352

14.13 - Résumé..................................................................................................................................................35214.14 - Exercices................................................................................................................................................352

15 - Polymorphisme & Fonctions Virtuelles............................................................................................................ 35415.1 - Evolution des programmeurs C++...........................................................................................................35415.2 - Transtypage ascendant (upcasting)........................................................................................................ 35515.3 - Le pr oblème.............................................................................................................................................356

15.3.1 - Liaison d'appel de fonction............................................................................................................. 356



8/436


- 8 -






15.4 - Fonctions virtuelles..................................................................................................................................35615.4.1 - Extensibilité......................................................................................................................................357

15.5 - Comment le C++ implémente la liaison tardive...................................................................................... 35915.5.1 - Stocker l'information de type...........................................................................................................35915.5.2 - Représenter les fonntions virtuelles................................................................................................36015.5.3 - Sous le capot.................................................................................................................................. 361

15.5.4 - Installer le vpointeur........................................................................................................................36215.5.5 - Les objets sont différents................................................................................................................362

15.6 - Pourquoi les fonctions virtuelles ?...........................................................................................................36315.7 - Classes de base abstraites et fonctions virtuelles pures........................................................................ 364

15.7.1 - Définitions virtuelles pures.............................................................................................................. 36615.8 - L'héritage et la VTABLE.......................................................................................................................... 367

15.8.1 - Découpage d'objets en tranches.....................................................................................................36915.9 - Surcharge & redéfinition..........................................................................................................................371

15.9.1 - Type de retour covariant................................................................................................................. 37215.10 - Fonctions virtuelles & constructeurs......................................................................................................373

15.10.1 - Ordre des appels au constructeur................................................................................................ 37415.10.2 - Comportement des fonctions virtuelles dans les constructeurs....................................................374

15.11 - Destructeurs et destructeurs virtuels..................................................................................................... 37515.11.1 - Destructeur s virtuels purs..............................................................................................................37615.11.2 - Les virtuels dans les destructeurs.................................................................................................37715.11.3 - Créer une hiérarchie basée sur objet........................................................................................... 378

15.12 - Surcharge d'opérateur........................................................................................................................... 38015.13 - Transtypage descendant....................................................................................................................... 38215.14 - Résumé..................................................................................................................................................38415.15 - Exercices................................................................................................................................................384

16 - Introduction aux Templates..............................................................................................................................38716.1 - Les conteneurs........................................................................................................................................ 387

16.1.1 - Le besoin de conteneurs................................................................................................................ 38816.2 - Survol des templates...............................................................................................................................389

16.2.1 - La solution template........................................................................................................................390

16.3 - Syntaxe des templates............................................................................................................................ 39116.3.1 - Définitions de fonctions non inline.................................................................................................. 39216.3.2 - IntStack comme template................................................................................................................39316.3.3 - Constantes dans les templates.......................................................................................................394

16.4 - Stack et Stash comme templates............................................................................................................39516.4.1 - Pointeur Stash modélisé................................................................................................................. 397

16.5 - Activer et désactiver la possession.........................................................................................................40116.6 - Stocker des objets par valeur................................................................................................................. 40216.7 - Pr ésentation des itérateurs......................................................................................................................404

16.7.1 - Stack avec itérateurs.......................................................................................................................40916.7.2 - PStash avec les iterateurs.............................................................................................................. 411

16.8 - Pourquoi les itérateurs ?..........................................................................................................................415

16.8.1 - Les templates de fonction...............................................................................................................41716.9 - Résumé....................................................................................................................................................41816.10 - Exercices................................................................................................................................................418

17 - Annexe A : Le style de codage....................................................................................................................... 42018 - Annexe B : Directives de programmation........................................................................................................ 42619 - Annexe C : Lectures recommandées.............................................................................................................. 432

19.1 - Langage C............................................................................................................................................... 43219.2 - Langage C++ en général........................................................................................................................ 432

19.2.1 - Ma propre liste de livres................................................................................................................. 43219.3 - Pr ofondeurs et recoins............................................................................................................................ 43319.4 - Analyse & conception..............................................................................................................................434

20 - Copyright et traduction.....................................................................................................................................43520.1 - Pour la version anglaise :........................................................................................................................43520.2 - Pour la version française :.......................................................................................................................436

20.2.1 - Equipe de traduction :..................................................................................................................... 436



9/436


- 9 -






20.2.2 - Relecteurs........................................................................................................................................43620.2.3 - Mise en place du projet.................................................................................................................. 437



10/436


- 10 -






0 - Préface

Comme n'importe quel langage humain, le C++ permet d'exprimer des concepts. S'il est réussi, ce supportd'expression sera plus simple et plus flexible que les solutions alternatives, qui au fur et à mesure que les problèmess'amplifient, deviennent plus complexes.

On ne peut pas simplement considérer le C++ comme un ensemble de fonctionnalités - certaines fonctionnalitésn'ayant pas de sens prises à part. On ne peut utiliser la somme des parties que si l'on pense conception, et nonsimplement code. Et pour comprendre le C++ de cette façon, il faut comprendre les problèmes liés au C et à laprogrammation en général. Ce livre traite des problèmes de programmation, pourquoi ce sont des problèmes, etl'approche que le C++ a prise pour résoudre de tels problèmes. Ainsi, le groupe de fonctionnalités que je traitedans chaque chapitre sera organisé selon la façon que j'ai de voir comment le langage résout un type particulier deproblème. De cette manière j'espère vous amener, au fur et à mesure, depuis la compréhension du C jusqu'au pointoù la mentalité C++ devient une seconde nature.

Du début à la fin, j'adopterai l'attitude selon laquelle vous voulez construire un modèle dans votre tête qui vouspermettra de comprendre le langage jusque dans ses moindres détails - si vous avez affaire à un puzzle, vous serez

capable de l'assembler selon votre modèle et d'en déduire la réponse. J'essayerai de vous transmettre les idées quiont réarrangé mon cerveau pour me faire commencer à «penser en C++.»

0.1 - Quoi de neuf dans cette seconde édition ?

Ce livre est une réécriture complète de la première édition pour refléter tous les changements introduits dans lelangage C++ par la finalisation du standard C++, et pour refléter également ce que j'ai appris depuis l'écriture de lapremière édition. L'ensemble du texte présent dans la première édition a été examiné et réécrit, parfois en supprimantde vieux exemples, souvent en modifiant les exemples existants et en en ajoutant de nouveaux, et en ajoutantbeaucoup de nouveaux exercices. Un réarrangement et un nouveau classement significatif du document ont eulieu afin de répercuter la disponibilité de meilleurs outils et ma meilleure appréhension de la façon dont les gensapprennent le C++. Un nouveau chapitre a été ajouté, rapide introduction aux concepts du C et aux fonctionnalités

de base du C++, pour ceux qui n'ont pas l'expérience du C pour aborder le reste du livre. Le CD ROM relié au dosdu livre contient une conférence qui est une introduction encore plus douce aux concepts du C nécessaires pour comprendre le C++ (ou le Java). Elle a été créée par Chuck Allison pour ma société (MindView, Inc.), et est appelée"Penser en C : Bases pour Java et C++." Elle vous présente les aspects du C nécessaires pour passer au C++ ouà Java, en laissant de côté les parties difficiles auxquelles les programmeurs C sont confrontés dans leur travail detous les jours, mais que les langages C++ et Java vous évitent d'utiliser (voire éliminent, dans le cas de Java).

Donc la réponse courte à la question "Qu'est-ce qui est nouveau dans la deuxième édition ?" est : ce qui n'est pasnouveau a été réécrit, parfois à tel point que vous ne reconnaitrez pas les exemples et le contenu d'origine.

0.1.1 - Qu'y a-t-il dans le Volume 2 de ce livre ?

L'achèvement du standard C++ a également ajouté un certain nombre de nouvelles bibliothèques importantes,comme les chaînes de caractères ( string) et les conteneurs et algorithmes de la bibliothèque standard du C++, aussibien que la nouvelle complexité des templates. Ces nouveautés et d'autres sujets plus avancés ont été relégués auvolume 2 de ce livre, y compris des problèmes tels l'héritage multiple, la gestion des exceptions, les modèles deconception, et les sujets sur les systèmes stables de compilation et de débogage.

0.1.2 - Comment récupérer le Volume 2 ?

Tout comme le livre que vous tenez actuellement, Penser en C++, Volume 2 est en téléchargement dans sa totalitésur mon site Web www.BruceEckel.com. Vous pouvez trouver la date d'impression prévue du Volume 2 sur le site.



11/436


- 11 -






Le site Web contient également le code source pour les deux livres, avec des mises à jour et des informations sur d'autres conférences-sur-CD ROM proposées par MindView, Inc., des conférences publiques, et des formations,consultations, tutelles, et visites internes.

0.2 - Prérequis

Dans la première édition de ce livre, je suis parti du principe que quelqu'un d'autre vous avait enseigné le C et quevous aviez au moins la capacité de le lire confortablement. Mon objectif premier était de simplifier ce que je trouvaisdifficile : le langage C++. Dans cette édition j'ai ajouté un chapitre qui est une rapide introduction au C, présentavec le CD du séminaire Penser en C , mais je considère toujours que vous avez déjà une certaine expérience enprogrammation. En outre, de même que vous apprenez beaucoup de nouveaux mots intuitivement en les voyantdans le contexte d'un roman, il est possible d'apprendre beaucoup sur C à partir du contexte dans lequel il est utilisédans le reste du livre.

0.3 - Apprendre le C++

J'ai suivi le même cheminement vers le C++ que les lecteurs de ce livre: avec une attidude très pragmatique enversla programmation, très "détails pratiques". Pire, mon passé et mon expérience étaient tournés vers la programmationembarquée niveau matériel, dans laquelle le C était souvent considéré comme un langage de haut-niveau et d'unesurpuissance inefficace pour déplacer des bits. J'ai découvert plus tard que je n'étais pas vraiment un très bonprogrammeur C, cachant mon ignorance des structures, malloc( ) et free( ), setjmp( ) et longjmp( ), et autresconcepts "sophistiqués", m'éloignant rapidement avec honte quand les conversations abordaient ces sujets, au lieude tendre vers de nouvelles connaissances.

Quand j'ai commencé ma lutte pour apprendre le C++, le seul livre décent était l'autoproclamé "Guide de l'expert,(1) ", de Bjarne Stroustrup, et j'étais donc livré à moi-même pour simplifier les concepts de base. Ceci a eu comme

conséquence mon premier livre sur le C++, (2) ce qui était essentiellement une extraction cérébrale de monexpérience. Il a été conçu comme un guide pour le lecteur afin d'introduire les programmeurs en même temps au C

et au C++. Les deux éditions (3) du livre ont entraîné une réaction enthousiaste.

Pratiquement en même temps que la sortie de Using C++, j'ai commencé à enseigner le langage dans desconférences et des présentations. Enseigner le C++ (et plus tard le Java) est devenu ma profession ; j'ai vu destêtes penchées, des visages livides, et des expressions embarrassées dans les assistances partout dans le mondedepuis 1989. Alors que je commençais à donner des formations internes à de plus petits groupes de personnes, j'aidécouvert une chose pendant les exercices. Mêmes ces personnes qui souriaient et acquiesçaient étaient perduesdevant de nombreux problèmes. J'ai découvert, en créant et présidant pendant de nombreuses années les sujetsC++ et Java à la conférence sur le développement logiciel, que les intervenants (moi compris) avaient tendance àprésenter au public type trop de sujets trop rapidement. Ainsi en définitive, du fait de la diversité des niveaux del'assistance et de la manière dont j'ai présenté le contenu, je finissais par perdre une partie du public. Peut-être est-ce trop demander, mais comme je suis une de ces personnes réfractaire aux cours traditionnels (et pour beaucoup,

je crois, une telle résistance est générée par l'ennui), j'ai voulu essayer de garder tout le monde dans le rythme.

Pendant quelques temps, j'ai créé un certain nombre de présentations différentes dans un ordre assez court. Ainsi, j'ai fini par apprendre par expérience et itération (une technique qui fonctionne également bien dans la conceptionde programmes C++). Par la suite, j'ai développé un cours en utilisant tout ce que j'avais appris de mon expérienced'enseignement. Il aborde le problème de l'apprentissage par des étapes distinctes, faciles à digérer, et pour impliquer l'auditoire (situation d'apprentissage idéale), des exercices suivent chacune des présentations. Vous pouvezdécouvrir mes conférences publiques sur www.BruceEckel.com, et vous pouvez également vous y renseigner sur les conférences que j'ai publié en CD ROM.

(1) Bjarne Stroustrup, The C++ Programming Language, Addison-Wesley, 1986 (première édition).(2) Using C++, Osborne/McGraw-Hill 1989.(3) Using C++ et C++ Inside & Out, Osborne/McGraw-Hill 1993.



12/436


- 12 -






La première édition de ce livre s'est développée dans un cheminement de deux ans, et le contenu de ce livre aété testé en situation dans beaucoup de formes dans de nombreuses conférences. Le retour que j'ai perçu dechaque conférence m'a aidé à modifier et recentrer le sujet jusqu'à ce que je sente qu'il fonctionne bien commeoutil didactique. Mais ce n'est pas simplement une documentation de conférence ; j'ai essayé d'entasser autantd'informations que possible dans ces pages, et de la structurer pour vous emmener vers le sujet suivant. Plus que toutautre chose, le livre est conçu pour servir le lecteur solitaire qui lutte avec un nouveau langage de programmation.

0.4 - Buts

Dans ce livre je me suis donné comme buts :

1 Présenter le cours pas à pas afin que le lecteur assimile chaque concept avant d'aller plus loin.2 Utiliser des exemples qui soient aussi simples et courts que possible. Souvent, cela me détournera des

problèmes « du monde réel », mais j'ai remarqué que les débutants sont généralement plus satisfaits decomprendre chaque détail d'un exemple qu'ils ne sont impressionnés par la portée du problème qu'il résout.Il y a également une limite à la taille du code qui peut être assimilé dans une situation de cours magistral,limite qu'il faut impérativement ne pas dépasser. A ce sujet je reçois parfois des critiques pour avoir utilisé

des « exemples jouets », et je les accepte volontiers, avec le prétexte que ce que je présente est utile,pédagogiquement parlant.3 Enchaîner soigneusement la présentation des fonctionnalités afin que l'on ne rencontre jamais quoi que ce

soit qui n'ait jamais été exposé. Bien entendu, ce n'est pas toujours possible, et, dans de telles situations, jedonnerai une brève description en introduction.

4 Montrer ce que je pense être important concernant la compréhension du langage, plutôt qu'exposer toutmon savoir. Je crois que l'information est fortement hiérarchisée, qu'il est avéré que 95 % des programmeursn'ont pas besoin de tout connaître, et que cela ne ferait que les embrouiller et accroître leur impression decomplexité du langage. Pour prendre un exemple en C, en connaissant par coeur le tableau de priorité desopérateurs (ce qui n'est pas mon cas), il est possible d'écrire un code astucieux. Mais si vous y réfléchissezun instant, ceci risque de dérouter le lecteur et/ou le mainteneur de ce code. Il est donc préférable d'oublier la priorité des opérateurs, et d'utiliser des parenthèses lorsque les choses ne sont pas claires. Une attitudesimilaire sera adoptée avec certaines informations du langage C++, qui je pense sont plus importantes pour

les réalisateurs de compilateurs que pour les programmeurs.5 Maintenir chaque section assez concentrée de telle manière que le temps de lecture - et le temps entre les

exercices - soit raisonnable. Non seulement cela maintient l'attention et l'implication des auditeurs lors d'unséminaire, mais cela donne au lecteur une plus grande impression de travail bien fait.

6 Munir les lecteurs de bases solides afin que leurs connaissances soient suffisantes pour suivre un cours oulire un livre plus difficiles (en particulier, le volume 2 de ce livre).

7 J'ai essayé de n'utiliser aucune version particulière d'un quelconque revendeur C++ parce que, pour apprendre un langage, je ne pense pas que les détails d'une implémentation particulière soient aussiimportants que le langage lui-même. La documentation fournie par les revendeurs au sujet de leurs propresspécificités d'implémentation est la plus part du temps suffisante.

0.5 - Chapitres

Le C++ est un langage dans lequel des fonctionnalités nouvelles et différentes ont été mises en place à partir d'unesyntaxe existante (de ce fait, il est considéré comme un langage de programmation orienté objet hybride). Au fur et à mesure que des gens dépassaient la phase d'apprentissage, nous avons commencé à comprendre la manièredont les développeurs franchissaient les étapes des fonctionnalités du langage C++. Puisque cela semblait être laprogression naturelle d'un esprit entraîné aux langages procéduraux, j'ai décidé de comprendre et de suivre moi-même ce cheminement et d'accélérer le processus en exprimant et en répondant aux questions qui me sont venuesalors que j'apprenais ce langage, ou qui sont venues de ceux à qui j'apprenais ce langage.

J'ai conçu ce cours en gardant une chose à l'esprit : améliorer le processus d'apprentissage du C++. Les réactionsde mes auditoires m'ont aidé à comprendre quelles parties étaient difficiles et nécessitaient des éclaircissements

particuliers. Dans les domaines dans lesquels j'ai été ambitieux et où j'ai inclus trop de fonctionnalités à la fois, j'ai été amené à comprendre - à travers la présentation de ces connaissances - que si vous incluez beaucoup denouvelles fonctionnalités, vous devez toutes les expliquer, et cela génère facilement la confusion des étudiants. En



13/436


- 13 -






conséquence, j'ai essayé d'introduire le moins de fonctionnalités possibles à la fois ; idéalement, un concept principalpar chapitre seulement.

L'objectif est alors d'enseigner un unique concept pour chaque chapitre, ou un petit groupe de concepts associés, detelle façon qu'aucune fonctionnalité additionnelle ne soit requise. De cette façon, vous pouvez digérer chaque partieen fonction de vos connaissances actuelles avant de passer à la suivante. Pour cela, j'ai conservé des fonctionnalités

du C plus longtemps que je ne l'aurais souhaité. L'avantage, c'est que vous ne serez pas perturbés par la découvertede fonctionnalités C++ utilisées avant d'être expliquées, et votre introduction à ce langage sera douce et reflétera lamanière dont vous l'auriez assimilé si vous deviez vous débrouiller seul.

Voici une rapide description des chapitres de cet ouvrage :

Chapitre 1 : Introduction à l'objet. Quand les projets sont devenus trop importants et complexes à maintenir simplement, la "crise du logiciel" est née, avec des programmeurs disant "Nous ne pouvons pas terminer les projets,et si nous le pouvons, ils sont trop cher

Documents

Penser en C++ vol.1 et 2