Penser en C++

Page 0
0. Préface
0.1. Quoi de neuf dans cette seconde édition ?
0.1.1. Qu'y a-t-il dans le Volume 2 de ce livre ?
0.1.2. Comment récupérer le Volume 2 ?
0.2. Prérequis
0.3. Apprendre le C++
0.4. Buts
0.5. Chapitres
0.6. Exercices
0.6.1. Solutions des exercices
0.7. Le Code Source
0.8. Normes du langage
0.8.1. Support du langage
0.9. Le CD ROM du livre
0.10. CD ROMs, conférences, et consultations
0.11. Erreurs
0.12. A propos de la couverture
0.13. Conception et production du livre
0.14. Remerciements
Page 1
1. Introduction sur les Objets
1.1. Les bienfaits de l'abstraction
1.2. Un objet dispose d'une interface
1.3. L'implémentation cachée
1.4. Réutilisation de l'implémentation
1.5. Héritage : réutilisation de l'interface
1.5.1. Les relations est-un vs. est-comme-un
1.6. Polymorphisme : des objets interchangeables
1.7. Créer et détruire les objets
1.8. Traitement des exceptions : gérer les erreurs
1.9. Analyse et conception
1.9.1. Phase 0 : Faire un plan
1.9.2. Phase 1 : Que construit-on ?
1.9.3. Phase 2 : Comment allons-nous le construire ?
1.9.4. Phase 3 : Construire le coeur du système
1.9.5. Phase 4 : Itérer sur les cas d'utilisation
1.9.6. Phase 5 : Evolution
1.9.7. Les plans sont payants
1.10. Extreme programming
1.10.1. Commencer par écrire les tests
1.10.2. Programmation en binôme
1.11. Les raisons du succès du C++
1.11.1. Un meilleur C
1.11.2. Vous êtes déjà sur la courbe d'apprentissage.
1.11.3. Efficacité
1.11.4. Les systèmes sont plus faciles à exprimer et à comprendre
1.11.5. Puissance maximale grâce aux bibliothèques
1.11.6. Réutilisation des sources avec les templates
1.11.7. Traitement des erreurs
1.11.8. Mise en oeuvre de gros projets
1.12. Stratégies de transition
1.12.1. Les grandes lignes
1.12.2. Ecueils de la gestion
1.13. Résumé
Page 2
2. Construire et utiliser les objets
2.1. Le processus de traduction du langage
2.1.1. Les interpréteurs
2.1.2. Les compilateurs
2.1.3. Le processus de compilation
2.2. Outils de compilation séparée
2.2.1. Déclarations vs. définitions
2.2.2. Edition des liens
2.2.3. Utilisation des bibliothèques
2.3. Votre premier programme C++
2.3.1. Utilisation de la classe iostream
2.3.2. Espaces de noms
2.3.3. Principes fondamentaux de structure de programme
2.3.4. "Bonjour tout le monde !"
2.3.5. Lancer le compilateur
2.4. Plus sur les flux d'entrée-sortie
2.4.1. Concaténation de tableaux de caractères
2.4.2. Lire les entrées
2.4.3. Appeler d'autres programmes
2.5. Introduction aux chaînes de caractères
2.6. Lire et écrire des fichiers
2.7. Intoduction à la classe vector
2.8. Résumé
2.9. Exercices
Page 3
3. Le C de C++
3.1. Création de fonctions
3.1.1. Valeurs de retour des fonctions
3.1.2. Utilisation de la bibliothèque de fonctions du C
3.1.3. Créer vos propres bibliothèques avec le bibliothécaire
3.2. Contrôle de l'exécution
3.2.1. Vrai et faux
3.2.2. if-else
3.2.3. while
3.2.4. do-while
3.2.5. for
3.2.6. Les mots clé break et continue
3.2.7. switch
3.2.8. Du bon et du mauvais usage du goto
3.2.9. Récursion
3.3. Introduction aux operateurs
3.3.1. Priorité
3.3.2. Auto incrémentation et décrémentation
3.4. Introduction aux types de données
3.4.1. Types intégrés de base
3.4.2. bool, true, & false
3.4.3. Spécificateurs
3.4.4. Introduction aux pointeurs
3.4.5. Modification d'objets extérieurs
3.4.6. Introduction aux références en C++
3.4.7. Pointeurs et références comme modificateurs
3.5. Portée des variables
3.6. Définir des variables "à la volée"
3.6. Définir l'allocation mémoire
3.6.1. Variables globales
3.6.2. Variables locales
3.6.3. static
3.6.4. extern
3.6.5. Constantes
3.6.6. volatile
3.7. Operateurs et leurs usages
3.7.1. L'affectation
3.7.2. Opérateurs mathématiques
3.7.3. Opérateurs relationnels
3.7.4. Opérateurs logiques
3.7.5. Opérateurs bit à bit
3.7.6. Opérateurs de décalage
3.7.7. Opérateurs unaires
3.7.8. L'opérateur ternaire
3.7.9. L'opérateur virgule
3.7.10. Piège classique quand on utilise les opérateurs
3.7.11. Opérateurs de transtypage
3.7.12. Transtypage C++ explicite
3.7.13. sizeof – Un opérateur par lui même
3.7.14. Le mot clef asm
3.7.15. Opérateurs explicites
3.8. Création de type composite
3.8.1. Alias de noms avec typedef
3.8.2. Combiner des variables avec des struct
3.8.3. Eclaircir les programmes avec des enum
3.8.4. Economiser de la mémoire avec union
3.8.5. Tableaux
3.9. Conseils de déboguage
3.9.1. Drapeaux de déboguage
3.9.2. Transformer des variables et des expressions en chaînes de caractère
3.9.3. la macro C assert( )
3.10. Adresses de fonctions
3.10.1. Définir un pointeur de fonction
3.10.2. Déclarations complexes & définitions
3.10.3. Utiliser un pointeur de fonction
3.10.4. Tableau de pointeurs de fonction
3.11. Make: gestion de la compilation séparée
3.11.1. Les actions du Make
3.11.2. Les makefiles de ce livre
3.11.3. Un exemple de makefile
3.12. Résumé
3.13. Exercices
Page 4
4. Abstraction des données
4.1. Une petite bibliothèque dans le style C
4.1.1. Allocation dynamique de mémoire
4.1.2. Mauvaises conjectures
4.2. Qu'est-ce qui ne va pas?
4.3. L'objet de base
4.4. Qu'est-ce qu'un objet?
4.5. Typage de données abstraites
4.6. Détails sur les objest
4.7. L'étiquette d'un fichier d'en-tête
4.7.1. L'importance des fichiers d'en-tête
4.7.2. Le problème des déclarations multiples
4.7.3. Les directives #define, #ifdef et #endif du préprocesseur
4.7.4. Un standard pour les fichiers d'en-tête
4.7.5. Les espaces de nommage dans les fichiers d'en-tête
4.7.6. Utiliser des fichiers d'en-tête dans des projets
4.8. Structures imbriquées
4.8.1. Résolution de portée globale
4.9. Résumé
4.10. Exercices
Page 5
5. Cacher l'implémentation
5.1. Fixer des limites
5.2. Le contrôle d'accès en C++
5.2.1. protected
5.3. L'amitié
5.3.1. Amis emboîtés
5.3.2. Est-ce pur ?
5.4. Organisation physique d'un objet
5.5. La classe
5.5.1. Modifier Stash pour employer le contrôle d'accès
5.5.2. Modifier Stack pour employer le contrôle d'accès
5.6. Manipuler les classes
5.6.1. Dissimuler l'implémentation
5.6.2. Réduire la recompilation
5.7. Résumé
5.8. Exercices
Page 6
6. Initialisation & Nettoyage
6.1. Initialisation garantie avec le constructeur
6.2. Garantir le nettoyage avec le destructeur
6.3. Elimination de la définition de bloc
6.3.1. les boucles
6.3.2. Allocation de mémoire
6.4. Stash avec constructueur et destructeur
6.5. Stack avec des constructeurs & des destructeurs
6.6. Initialisation d'aggrégat
6.7. Les constructeurs par défaut
6.8. Résumé
6.9. Exercices
Page 7
7. Fonctions surchargée et arguments par défaut
7.1. Plus sur les décorations de nom
7.1.1. Valeur de retour surchargée :
7.1.2. Edition de liens sécurisée
7.2. Exemple de surchargement
7.3. unions
7.4. Les arguments par défaut
7.4.1. Paramètre fictif
7.5. Choix entre surcharge et arguments par défaut
7.6. Résumé
7.7. Exercices
Page 8
8. Constantes
8.1. Substitution de valeurs
8.2. Les pointeurs
8.2.1. Pointeur vers const
8.2.2. Pointeur const
8.2.3. Assignation et vérification de type
8.3. Arguments d'une fonction & valeurs retournées
8.3.1. Passer par valeur const
8.3.2. Retour par valeur const
8.3.3. Passer et retourner des adresses
8.4. Classes
8.4.1. const dans les classes
8.4.2. Constantes de compilation dans les classes
8.4.3. objets cont & fonctions membres
8.5. volatile
8.6. Résumé
8.7. Exercices
Page 9
9. Fonctions inlines
9.1. Ecueils du préprocesseurs
9.1.1. Les macros et l'accès
9.2. Fonctions inline
9.2.1. Les inline dans les classes
9.2.2. Fonctions d'accès
9.3. Stash & Stack avec les inlines
9.4. Les inline & le compilateur
9.4.1. Limitations
9.4.2. Déclarations aval
9.4.3. Activités cachées dans les constructeurs et les destructeurs
9.5. Réduire le fouillis
9.6. Caractéristiques supplémentaires du préprocesseur
9.6.1. Collage de jeton
9.7. Vérification d'erreurs améliorée
9.8. Résumé
9.9. Exercices
Page 10
10. Contrôle du nom
10.1. Eléments statiques issus du C
10.1.1. Variables statiques à l'intérieur des fonctions
10.1.2. Contrôle de l'édition de liens
10.1.3. Autre spécificateurs de classe de stockage
10.2. Les namespaces
10.2.1. Créer un espace de nommage
10.2.2. Utiliser un espace de nommage
10.2.3. L'utilisation des espace de nommage
10.3. Membres statiques en C++
10.3.1. Définir le stockage pour les données membres statiques
10.3.2. Classes imbriquées et locales
10.3.3. Fonctions membres statiques
10.4. Dépendance de l'initialisation statique
10.4.1. Que faire
10.5. Spécification alternative des conventions de liens
10.6. Sommaire
10.7. Exercices
Page 11
11. Références & le constructeur de copie
11.1. Les pointeurs en C++
11.2. Les références en C++
11.2.1. Les références dans les fonctions
11.2.2. Indications sur le passage d'arguments
11.3. Le constructeur par recopie
11.3.1. Passer & renvoyer par valeur
11.3.2. Construction par recopie
11.3.3. Constructeur par recopie par défaut
11.3.4. Alternatives à la construction par recopie
11.4. Pointeurs sur membre
11.4.1. Fonctions
11.5. Résumé
11.6. Exercices
Page 12
12. Surcharges d'opérateurs
12.1. Soyez avertis et rassurés
12.2. Syntaxe
12.3. Opérateurs surchargeables
12.3.1. Opérateurs unaires
12.3.2. Opérateurs binaires
12.3.3. Arguments & valeurs de retour
12.3.4. opérateurs inhabituels
12.3.5. Opérateurs que vous ne pouvez pas surcharger
12.4. Opérateurs non membres
12.4.1. Conseils élémentaires
12.5. Surcharge de l'affectation
12.5.1. Comportement de operator=
12.6. Conversion de type automatique
12.6.1. Conversion par constructeur
12.6.2. Conversion par opérateur
12.6.3. Exemple de conversion de type
12.6.4. Les pièges de la conversion de type automatique
12.7. Résumé
12.8. Exercices
Page 13
13. Création d'Objets Dynamiques
13.1. Création d'objets
13.1.1. L'approche du C au tas
13.1.2. l'operateur new
13.1.3. l'opérateur delete
13.1.4. Un exemple simple
13.1.5. Le surcoût du gestionnaire de mémoire
13.2. Exemples précédents revus
13.2.1. detruire un void* est probablement une erreur
13.2.2. La responsabilité du nettoyage avec les pointeurs
13.2.3. Stash pour des pointeurs
13.3. new & delete pour les tableaux
13.3.1. Rendre un pointeur plus semblable à un tableau
13.4. Manquer d'espace de stockage
13.5. Surcharger new & delete
13.5.1. La surcharge globale de new & delete
13.5.2. Surcharger new & delete pour une classe
13.5.3. Surcharger new & delete pour les tableaux
13.5.4. Appels au constructeur
13.5.5. new & delete de placement
13.6. Résumé
13.7. Exercices
Page 14
14. Héritage & composition
14.1. Syntaxe de la composition
14.2. Syntaxe de l'héritage
14.3. La liste d'initialisation du construteur
14.3.1. Initialisation d'un objet membre
14.3.2. Types prédéfinis dans la liste d'initialisation
14.4. Combiner composition & héritage
14.4.1. Ordre des appels des constructeurs & et des destructeurs
14.5. Masquage de nom
14.6. Fonctions qui ne s'héritent pas automatiquement
14.6.1. Héritage et fonctions membres statiques
14.7. Choisir entre composition et héritage
14.7.1. Sous-typer
14.7.2. héritage privé
14.8. protected
14.8.1. héritage protégé
14.9. Surcharge d'opérateur & héritage
14.10. Héritage multiple
14.11. Développement incrémental
14.12. Transtypage ascendant
14.12.1. Pourquoi "ascendant" ?
14.12.2. Le transtypage ascendant et le constructeur de copie
14.12.3. Composition vs. héritage (révisé)
14.12.4. Transtypage ascendant de pointeur & de reference
14.12.5. Une crise
14.13. Résumé
14.14. Exercices
Page 15
15. Polymorphisme & Fonctions Virtuelles
15.1. Evolution des programmeurs C++
15.2. Transtypage ascendant ( upcasting)
15.3. Le problème
15.3.1. Liaison d'appel de fonction
15.4. Fonctions virtuelles
15.4.1. Extensibilité
15.5. Comment le C++ implémente la liaison tardive
15.5.1. Stocker l'information de type
15.5.2. Représenter les fonntions virtuelles
15.5.3. Sous le capot
15.5.4. Installer le vpointeur
15.5.5. Les objets sont différents
15.6. Pourquoi les fonctions virtuelles ?
15.7. Classes de base abstraites et fonctions virtuelles pures
15.7.1. Définitions virtuelles pures
15.8. L'héritage et la VTABLE
15.8.1. Découpage d'objets en tranches
15.9. Surcharge & redéfinition
15.9.1. Type de retour covariant
15.10. Fonctions virtuelles & constructeurs
15.10.1. Ordre des appels au constructeur
15.10.2. Comportement des fonctions virtuelles dans les constructeurs
15.11. Destructeurs et destructeurs virtuels
15.11.1. Destructeurs virtuels purs
15.11.2. Les virtuels dans les destructeurs
15.11.3. Créer une hiérarchie basée sur objet
15.12. Surcharge d'opérateur
15.13. Transtypage descendant
15.14. Résumé
15.15. Exercices
Page 16
16. Introduction aux Templates
16.1. Les conteneurs
16.1.1. Le besoin de conteneurs
16.2. Survol des templates
16.2.1. La solution template
16.3. Syntaxe des templates
16.3.1. Définitions de fonctions non inline
16.3.2. IntStack comme template
16.3.3. Constantes dans les templates
16.4. Stack et Stash comme templates
16.4.1. Pointeur Stash modélisé
16.5. Activer et désactiver la possession
16.6. Stocker des objets par valeur
16.7. Présentation des itérateurs
16.7.1. Stack avec itérateurs
16.7.2. PStash avec les iterateurs
16.8. Pourquoi les itérateurs ?
16.8.1. Les templates de fonction
16.9. Résumé
16.10. Exercices
Page 17
17. Annexe A : Le style de codage
Page 18
18. Annexe B : Directives de programmation
Page 19
19. Annexe C : Lectures recommandées
19.1. Langage C
19.2. Langage C++ en général
19.2.1. Ma propre liste de livres
19.3. Profondeurs et recoins
19.4. Analyse & conception
Page 20
20. Copyright et traduction
20.1. Pour la version anglaise :
20.2. Pour la version française :
20.2.1. Equipe de traduction :
20.2.2. Relecteurs
20.2.3. Mise en place du projet