Extrait du cours programmation en C++

……
Ci-dessus tab1 est un objet de la classe vector<int>. La classe vector<int> est une classe de tableaux dont les éléments stockés sont des entiers. L’objet tab1 est donc un tableau d’entiers. La taille initiale du tableau est passée au constructeur de l’objet. L’objet tab1 peut donc stocker 4 entiers, tab2 peut stocker 2 float et tab3 peut stocker 2 objets de la classe vector<int>. On peut donc copier tab1 dans une case du tableau tab3 (tab3 est un tableau de tableaux).
Remarquer que l’accès à une case d’un objet vector<T> se fait simplement avec l’opérateur [ ] ,  comme sur un tableau classique en C. Mais la classe vector<T> dispose de bien d’autres méthodes utilisables pour changer la taille, insérer des éléments, supprimer des éléments. Par exemple, on voit ci-dessus  l’utilisation de la méthode vector<T>::size() sur l’objet tab1.
L’objectif n’est pas de détailler ici toutes les possibilités d’utilisation des classes paramétrées de la bibliothèque STL, mais de présenter simplement quelques caractéristiques des classes string, vector , et list.
Ces classes paramétrées vont fournir des briques intéressantes pour créer des classes plus complexes dans les chapitres suivants.
6.2. Namespace
Avant d’aller plus loin dans la présentation de la STL, il semble temps d’expliquer ce que représente un namespace (espace de noms). Différentes classes ou fonctions peuvent être regroupées dans un espace de noms particulier pour éviter certains conflits d’identifiant. Dès lors, pour utiliser une classe d’un espace de noms particulier, on doit faire précéder le nom de la classe du nom de l’espace de noms. On peut aussi préciser un namespace par défaut pour le programme via la directive using namespace.
Dans l’exemple qui suit, il n’y a pas de conflit de nom puisque les deux fonctions sont définies dans deux espaces de noms distincts (les namespaces NA et NB). On voit aussi que le flot cout dépend du namespace std.
……..

Sommaire: Programmation en C++

1. Introduction du cours de C++
2. Le C++ en dehors des classes d’objets
2.1. Les notions du C utilisées en C++
2.2. Les références en C++
2.3. Les paramètres avec valeurs par défaut
2.4. La surcharge de fonctions
3. Introduction à la POO et à la représentation de classes en UML
4. Les classes en C++
4.1. Les classes ostream et istream
4.2. Méthodes et attributs
4.3. Constructeurs : méthodes d’initialisation d’un objet
4.4. Différence entre sélecteurs/accesseurs et modificateurs
4.5. Constructeur de copie, opérateur d’affectation
5. Les opérateurs : fonctions globales ou méthodes d’une classe
5.1. La pluralité des opérateurs du C++
5.2. Les opérateurs avec traitement par défaut
5.3. Les opérateurs que l’on peut surcharger en C++
5.4. Le mécanisme de définition des opérateurs en C++
5.5. Exemple : classe de nombres rationnels
6. L’utilisation de classes paramétrées en type (introduction à la bibliothèque STL)
6.1. Introduction
6.2. Namespace
6.3. Classe string
6.4. Conteneurs vector<T>
6.5. Conteneurs list<T>
7. Réalisation de la composition en C++
7.1. Représentation UML de la composition
7.2. Objets composants comme attributs d’une classe
7.3. Utilisation d’attributs de type tableau d’objets
7.4. Utilisation d’un objet membre de type vector<T>
8. Réalisation de la spécialisation en C++
8.1. Représentation de la spécialisation en UML.
8.2. Exemple de réalisation de la spécialisation en C++
8.3. Les conversions de type entre sous-classe et super-classe
8.4. Le polymorphisme et les méthodes virtuelles
8.5. Les classes abstraites
9. Visibilité des membres d’une classe
9.1. Mot-clé friend : fonctions ou classes amies
9.2. Membres protégés (mot-clé protected) et visibilité des membres
9.3. Navigation dans une hiérarchie de classes, phénomènes de masquage
10. Classes avec données en profondeur
10.1. Les opérateurs de gestion de mémoire (new et delete)
10.2. Réalisation de la composition par gestion dynamique de mémoire (données en profondeur)
10.3. Réalisation de conteneurs : tableaux, piles, files, listes
11. Les fonctions et les classes paramétrées en type
11.1. Les fonctions paramétrées en type
11.2. Classes paramétrées en type
12. Les flots entrée/sortie, les fichiers
12.1. Les déclarations d’énumérations au sein des classes
12.2. La déclaration d’une classe au sein d’une classe
12.3. La hiérarchie des classes de flots
12.4. Les fichiers
12.5. L’accès direct dans les fichiers
13. Les changements de type
13.1. Les constructeurs comme convertisseurs de type
13.2. Conversion d’un type classe vers un type primitif
14. Conclusion et fiches synthétiques
………

Si le lien ne fonctionne pas correctement, veuillez nous contacter (mentionner le lien dans votre message)
Programmation en C++ (208 KO) (Cours PDF)