Le langage C++ Henri Garreta

Transcription

1 Faculté des Sciences de Luminy Département d Informatique Le langage C++ Henri Garreta Table des matières 1 Eléments préalables Placement des déclarations de variables Booléens Références Notion Références paramètres des fonctions Fonctions renvoyant une référence Références sur des données constantes Références ou pointeurs? Fonctions en ligne Valeurs par défaut des arguments des fonctions Surcharge des noms de fonctions Appel et définition de fonctions écrites en C Entrées-sorties simples Allocation dynamique de mémoire Classes Classes et objets Accès aux membres Accès aux membres d un objet Accès à ses propres membres, accès à soi-même Membres publics et privés Encapsulation au niveau de la classe Structures Définition des classes Définition séparée et opérateur de résolution de portée Fichier d en-tête et fichier d implémentation Constructeurs Définition de constructeurs Appel des constructeurs Constructeur par défaut Constructeur par copie (clonage) Construction des objets membres Destructeurs Membres constants Données membres constantes Fonctions membres constantes Membres statiques Données membres statiques Fonctions membres statiques Amis Fonctions amies Classes amies

2 3 Surcharge des opérateurs Principe Surcharge d un opérateur par une fonction membre Surcharge d un opérateur par une fonction non membre Quelques exemples Injection et extraction de données dans les flux Affectation Opérateurs de conversion Conversion vers un type classe Conversion d un objet vers un type primitif Héritage Classes de base et classes dérivées Héritage et accessibilité des membres Membres protégés Héritage privé, protégé, public Redéfinition des fonctions membres Création et destruction des objets dérivés Récapitulation sur la création et destruction des objets Construction Destruction Polymorphisme Conversion standard vers une classe de base Type statique, type dynamique, généralisation Fonctions virtuelles Classes abstraites Identification dynamique du type L opérateur dynamic cast L opérateur typeid Modèles (templates) Modèles de fonctions Modèles de classes Fonctions membres d un modèle Exceptions Principe et syntaxe Attraper une exception Déclaration des exceptions qu une fonction laisse échapper La classe exception mars 2002 henri.garreta@luminy.univ-mrs.fr 2

3 1 Eléments préalables Ce document est le support du cours sur le langage C++, considéré comme une extension de C (tel que normalisé par l ISO en 1990), langage présumé bien connu. Attention, la présentation faite ici est déséquilibrée : des concepts importants ne sont pas expliqués, pour la raison qu ils sont réalisés en C++ comme en C, donc supposés acquis. En revanche, nous insistons sur les différences entre C et C++ et notamment sur tous les éléments orientés objets que C++ ajoute à C. Cette première section expose un certain nombre de notions qui, sans être directement liés à la méthodologie objets, font déjà apparaître C++ comme une amélioration notable de C. 1.1 Placement des déclarations de variables En C les déclarations de variables doivent apparaître au début d un bloc. En C++, au contraire, on peut mettre une déclaration de variable partout où on peut mettre une instruction 1. Cette différence paraît mineure, mais elle est importante par son esprit. Elle permet de repousser la déclaration d une variable jusqu à l endroit du programme où l on dispose d assez éléments pour l initialiser. On lutte aussi contre les variables déjà déclarées mais non encore initialisées qui sont un important vivier de bugs dans les programmes. Exemple, l emploi d un fichier. Version C : { FILE *fic; obtention de nomfic, le nom du fichier à ouvrir Danger! Tout emploi de fic ici est erroné fic = fopen(nom, "w"); ici, l emploi de fic est légitime Version C++ : { obtention de nomfic, le nom du fichier à ouvrir ici pas de danger d utiliser fic à tort FILE *fic = fopen(nom, "w"); ici, l emploi de fic est légitime 1.2 Booléens En plus des types définis par l utilisateur (ou classes, une des notions fondamentales de la programmation orientée objets) C++ possède quelques types qui manquaient à C, notamment le type booléen et les types références. Le type bool (pour booléen) comporte deux valeurs : false et true. Contrairement à C : le résultat d une opération logique (&&,, etc.) est de type booléen, là où une condition est attendue on doit mettre une expression de type booléen et il est déconseillé de prendre les entiers pour des booléens et réciproquement. Conséquence pratique : n écrivez pas if (x) au lieu de if (x!= 0) 1.3 Références Notion A côté des pointeurs, les références sont une autre manière de manipuler les adresses des objets placés dans la mémoire. Une référence est un pointeur géré de manière interne par la machine. Si T est un type donné, le 1 Bien entendu, une règle absolue reste en vigueur : une variable ne peut être utilisée qu après qu elle ait été déclarée. 3

4 type référence sur T se note T &. Exemple : int i; int & r = i; // r est une référence sur i Une valeur de type référence est une adresse mais, hormis lors de son initialisation, toute opération effectuée sur la référence agit sur l objet référencé, non sur l adresse. Il en découle qu il est obligatoire d initialiser une référence lors de sa création ; après, c est trop tard : r = j; Références paramètres des fonctions // ceci ne transforme pas r en une référence // sur j mais copie la valeur de j dans i L utilité principale des références est de permettre de donner aux fonctions des paramètres modifiables, sans utiliser explicitement les pointeurs. Exemple : void permuter(int & a, int & b) { int w = a; a = b; b = w; Lors d un appel de cette fonction, comme permuter(t[i], u); ses paramètres formels a et b sont initialisés avec les adresses des paramètres effectifs t[i] et u, mais cette utilisation des adresses reste cachée, le programmeur n a pas à s en occuper. Autrement dit, à l occasion d un tel appel, a et b ne sont pas des variables locales de la fonction recevant des copies des valeurs des paramètres, mais d authentiques synonymes des variables t[i] et u. Il en résulte que l appel ci-dessus permute effectivement les valeurs des variables t[i] et u Fonctions renvoyant une référence Il est possible d écrire des fonctions qui renvoient une référence comme résultat. Cela leur permet d être le membre gauche d une affectation, ce qui donne lieu à des expressions élégantes et efficaces. Par exemple, voici comment une fonction permet de simuler un tableau indexé par des chaînes de caractères 3 : char *noms[n]; int ages[n]; int & age(char *nom) { for (int i = 0; i < N; i++) if (strcmp(nom, noms[i]) == 0) return ages[i]; Une telle fonction permet l écriture d expressions qui ressemblent à des accès à un tableau dont les indices seraient des chaînes : ou encore age("amélie") = 20; age("benjamin")++; Références sur des données constantes Lors de l écriture d une fonction il est parfois souhaitable d associer l efficacité des arguments références (puisque dans le cas d une référence il n y a pas recopie de la valeur de l argument) et la sécurité des arguments par valeur (qui ne peuvent en aucun cas être modifiés par la fonction). Cela peut se faire en déclarant des arguments comme des références sur des objets immodifiables, ou constants, à l aide du qualifieur const : 2 Notez qu une telle chose est impossible en C, où une fonction appelée par l expression permuter(t[i], u) ne peut recevoir que des copies des valeurs de de t[i] et u. 3 C est un exemple simpliste, pour faire court nous n y avons pas traité le cas de l absence de la chaîne cherchée. 4

5 void unefonction(const untype & arg) { ici arg n est pas une recopie de l argument effectif (puisque référence) mais il ne peut pas être modifié par la fonction (puisque const) Références ou pointeurs? Il existe quelques situations, nous les verrons plus loin, où les références se révèlent indispensables. Cependant, la plupart du temps elles font double emploi avec les pointeurs et il n existe pas de critères simples pour choisir des références plutôt que des pointeurs ou le contraire. Par exemple, la fonction permuter montrée à la page précédente peut s écrire aussi : void permuter(int *a, int *b) { int w = *a; *a = *b; *b = w; son appel s écrit alors permuter(&t[i], &u); Attention On notera que l opérateur & (à un argument) a une signification très différente selon le contexte dans lequel il apparaît : employé dans une déclaration, comme dans int &r = x; il sert à indiquer un type référence : r est une référence sur un int employé ailleurs que dans une déclaration il indique l opération obtention de l adresse, comme dans l expression suivante qui signifie affecter l adresse de x à p : p = &x; enfin, on doit se souvenir qu il y a en C++, comme en C, un opérateur & binaire (à deux arguments) qui exprime la conjonction bit-à-bit de deux mots-machine. 1.4 Fonctions en ligne Normalement, un appel de fonction est une rupture de séquence : à l endroit où un appel figure, la machine cesse d exécuter séquentiellement les instructions en cours ; les arguments de l appel sont disposés sur la pile d exécution, et l exécution continue ailleurs, là où se trouve le code de la fonction. Une fonction en ligne est le contraire de cela : là où l appel d une telle fonction apparaît il n y a pas de rupture de séquence. Au lieu de cela, le compilateur remplace l appel de la fonction par le corps de celle-ci, en mettant les arguments affectifs à la place des arguments formels. Cela se fait dans un but d efficacité : puisqu il n y a pas d appel, pas de préparation des arguments, pas de rupture de séquence, pas de retour, etc. Mais il est clair qu un tel traitement ne peut convenir qu à des fonctions fréquemment appelées (si une fonction ne sert pas souvent, à quoi bon la rendre plus rapide?) de petite taille (sinon le code compilé risque de devenir démesurément volumineux) et rapides (si une fonction effectue une opération lente, le gain de temps obtenu en supprimant l appel est négligeable). En C++ on indique qu une fonction doit être traitée en ligne en faisant précéder sa déclaration par le mot inline : inline int abs(int x) { return x >= 0? x : -x; Les fonctions en ligne de C++ rendent le même service que les macros (avec arguments) de C, mais on notera que les fonctions en ligne sont plus fiables car, contrairement à ce qui se passe pour les macros, le compilateur peut y effectuer tous les contrôles syntaxiques et sémantiques qu il fait sur les fonctions ordinaires. La portée d une fonction en ligne est réduite au fichier où la fonction est définie. Par conséquent, de telles fonctions sont généralement écrites dans des fichiers en-tête (fichiers.h ), qui doivent être inclus dans tous les fichiers comportant des appels de ces fonctions. 5

6 1.5 Valeurs par défaut des arguments des fonctions Les paramètres formels d une fonction peuvent avoir des valeurs par défaut. Exemple : void trier(void *table, int nbr, int taille = sizeof(void *), bool croissant = true); Lors de l appel d une telle fonction, les paramètres effectifs correspondants peuvent alors être omis (ainsi que les virgules correspondantes), les paramètres formels seront initialisés avec les valeurs par défaut. Exemples : trier(t, n, sizeof(int), false); trier(t, n, sizeof(int)); // croissant = true trier(t, n); // taille = sizeof(void *), croissant = true 1.6 Surcharge des noms de fonctions La signature d une fonction est la suite des types de ses arguments formels (et quelques éléments supplémentaires, que nous verrons plus loin). Le type du résultat rendu par la fonction ne fait pas partie de sa signature. La surcharge des noms des fonctions consiste en ceci : en C++ des fonctions différentes peuvent avoir le même nom, à la condition que leurs signatures soient assez différentes pour que, lors de chaque appel, le nombre et les types des arguments effectifs permettent de choisir sans ambiguïté la fonction à appeler. Exemple : int puissance(int x, int n) { calcul de x n avec x et n entiers double puissance(double x, int n) { calcul de x n avec x flottant et n entier double puissance(double x, double y) { calcul de x y avec x et y flottants On voit sur cet exemple l intérêt de la surcharge des noms des fonctions : la même notion abstraite x à la puissance n se traduit par des algorithmes très différents selon que n est entier (x n = x.xx) ou réel (x n = e n log x ) ; de plus, pour n entier, si on veut que x n soit entier lorsque x est entier, on doit écrire deux fonctions distinctes, une pour x entier et une pour x réel. Or le programmeur n aura qu un nom à connaître, puissance. Il écrira dans tous les cas c = puissance(a, b); le compilateur se chargeant de choisir la fonction la plus adaptée, selon les types de a et b. Notes. 1. Le type du résultat rendu par la fonction ne fait pas partie de la signature. Par conséquent, on ne peut pas donner le même nom à deux fonctions qui ne différent que par le type du résultat qu elles rendent. 2. Lors de l appel d une fonction surchargée, la fonction effectivement appelée est celle dont la signature correspond avec les types des arguments effectifs de l appel. S il y a une correspondance exacte, pas de problème. S il n y a pas de correspondance exacte, alors des règles complexes (trop complexes pur les expliquer ici) s appliquent, pour déterminer la fonction à appeler. Malgré ces règles, il existe de nombreux cas de figure ambigus, que le compilateur ne peut pas résoudre. Par exemple, si x est flottant et n entier, l appel puissance(n, x) est erroné, alors qu il aurait été correct s il y avait eu une seule définition de la fonction puissance (les conversions entier flottant nécessaires auraient alors été faites). 1.7 Appel et définition de fonctions écrites en C Pour que la compilation et l édition de liens d un programme avec des fonctions surchargées soient possibles, le compilateur C++ doit fabriquer pour chaque fonction un nom long comprenant le nom de la fonction et une représentation codée de sa signature ; c est ce nom long qui est communiqué à l éditeur de liens. Or, les fonctions produites par un compilateur C n ont pas de tels noms longs ; si on ne prend pas de disposition particulière, il sera donc impossible d appeler dans un programme C++ une fonction écrite en C, ou réciproquement. On remédie à cette impossibilité par l utilisation de la déclaration extern C : extern "C" { déclarations et définitions d éléments dont le nom est représenté à la manière de C 6

7 1.8 Entrées-sorties simples Cette section traite de l utilisation simple des flux standard d entrée-sortie, c est-à-dire la manière de faire en C++ les opérations qu on fait habituellement en C avec les fonctions printf et scanf. Un programme qui utilise les flux standard d entrée-sortie doit comporter la directive #include <iostream.h> ou bien, si vous utilisez un compilateur récent et que vous suivez de près les recommandations de la norme 4 : #include <iostream> using namespace std; Les flux d entrée-sortie sont représentés dans les programmes par les trois variables, prédéclarées et préinitialisées, suivantes : cin, le flux standard d entrée (l équivalent du stdin de C), qui est habituellement associé au clavier du poste de travail, cout, le flux standard de sortie (l équivalent du stdout de C), qui est habituellement associé à l écran du poste de travail, cerr, le flux standard pour la sortie des messages d erreur (l équivalent du stderr de C), également associé à l écran du poste de travail. Les écritures et lectures sur ces unités ne se font pas en appelant des fonctions, mais à l aide des opérateurs <<, appelé opérateur d injection ( injection de données dans un flux de sortie), et >>, appelé opérateur d extraction ( extraction de données d un flux d entrée). Or, le mécanisme de la surcharge des opérateurs (voir la section 3) permet la détection des types des données à lire ou à écrire. Ainsi, le programmeur n a pas à s encombrer avec des spécifications de format. La syntaxe d un injection de donnée sur la sortie standard cout est : cout << expression à écrire le résultat de cette expression est l objet cout lui-même. On peut donc lui injecter une autre donnée, puis encore une, etc. : ((cout << expression ) << expression ) << expression ce qui, l opérateur << étant associatif à gauche, se note aussi, de manière bien plus agréable : cout << expression << expression << expression Le même procédé existe avec l extraction depuis cin. Par exemple, le programme suivant est un programme C++ complet. Il calcule x n (pour x flottant et n entier). #include <iostream.h> double puissance(double x, int n) { algorithme de calcul de x n void main() { double x; int n; cout << "Donne x et n : "; cin >> x >> n; cout << x << "^" << n << " = " << puissance(x, n) << "\n"; Exemple d exécution de ce programme : Donne x et n : ^10 = C est-à-dire, si vous utilisez les espaces de noms, ou namespace (tous les éléments de la bibliothèque standard sont dans l espace de noms std). 7

8 1.9 Allocation dynamique de mémoire Des différences entre C et C++ existent aussi au niveau de l allocation et de la restitution dynamique de mémoire. Les fonctions malloc et free de la bibliothèque standard C sont disponibles en C++. Mais il est fortement conseillé de leur préférer les opérateurs new et delete. La raison principale est la suivante : les objets créés à l aide de new sont initialisés à l aide des constructeurs (cf. section 2.4) correspondants, ce que ne fait pas malloc. De même, les objets liberés en utilisant delete sont finalisés en utilisant le destructeur (cf. section 2.6) de la classe correspondante, contrairement à ce que fait free. Pour allouer un unique objet : new type Pour allouer un tableau de n objets : new type[n] Dans les deux cas, new renvoie une valeur de type pointeur sur un type, c est-à-dire type *. Exemples (on suppose que Machin est un type défini par ailleurs) : Machin *ptr = new Machin; int *tab = new int[n]; // un objet Machin // un tableau de n int Si type est une classe possédant un constructeur par défaut, celui-ci sera appelé une fois (cas de l allocation d un objet simple) ou n fois (allocation d un tableau d objets) pour construire l objet ou les objets alloués. Si type est une classe sans constructeur par défaut, une erreur sera signalée par le compilateur. Pour un tableau, la dimension n peut être donnée par une variable, c est-à-dire être inconnue lors de la compilation, mais la taille des composantes doit être connue. Il en découle que dans le cas d un tableau à plusieurs indices, seule la première dimension peut être non constante : double (*M)[10]; acquisition de la valeur de n M = new double[n][10]; // pointeur de tableaux de 10 double // allocation d un tableau de n tableaux de 10 double M pourra ensuite être utilisé comme une matrice à n lignes et 10 colonnes. L opérateur delete restitue la mémoire dynamique. Si la valeur de p a été obtenue par un appel de new, on écrit delete p; dans le cas d un objet qui n est pas un tableau, et delete [] p; si ce que p pointe est un tableau. Les conséquences d une utilisation de delete là où il aurait fallu utiliser delete[], ou inversement, sont imprévisibles. 2 Classes 2.1 Classes et objets Un objet est constitué par l association d une certaine quantité de mémoire, organisée en champs, et d un ensemble de fonctions, destinées principalement à la consultation et la modification des valeurs de ces champs. La définition d un type objet s appelle une classe. D un point de vue syntaxique, cela ressemble beaucoup à une définition de structure, sauf que le mot réservé class remplace 5 le mot struct, certains champs de la classe sont des fonctions. Par exemple, le programme suivant est une première version d une classe Point destinée à représenter les points affichés dans une fenêtre graphique : 5 En fait on peut aussi utiliser struct, voyez la section

9 class Point { void afficher() { cout << ( << x <<, << y << ) ; void placer(int a, int b) { validation des valeurs de a et b; x = a; y = b; private: int x, y; ; Chaque objet de la classe Point comporte un peu de mémoire, composée de deux entiers x et y, et de deux fonctions : afficher, qui accède à x et y sans les modifier, et placer, qui change les valeurs de x et y. L association de membres et fonctions au sein d une classe, avec la possibilité de rendre privés certains d entre eux, s appelle l encapsulation des données. Intérêt de la démarche : puisqu elles ont été déclarées privées, les coordonnées x et y d un point ne peuvent être modifiées autrement que par un appel de la fonction placer sur ce point. Or, en prenant les précautions nécessaires lors de l écriture de cette fonction (ce que nous avons noté validation des valeurs de a et b ) le programmeur responsable de la classe Point peut garantir aux utilisateurs de cette classe que tous les objets crées auront toujours des coordonnées correctes. Autrement dit : chaque objet peut prendre soin de sa propre cohérence interne. Autre avantage important : on pourra à tout moment changer l implémentation (i.e. les détails internes) de la classe tout en ayant la certitude qu il n y aura rien à changer dans les programmes qui l utilisent. Note. Dans une classe, les déclarations des membres peuvent se trouver dans un ordre quelconque, même lorsque ces membres se référencent mutuellement. Dans l exemple précédent, le membre afficher mentionne les membres x et y, dont la définition se trouve après celle de afficher. Jargon. On appelle objet une donnée d un type classe ou structure, fonction membre un membre d une classe qui est une fonction 6, donnée membre un membre qui est une variable Accès aux membres Accès aux membres d un objet On accède aux membres des objets en C++ comme on accède aux membres des structures en C. Par exemple, à la suite de la définition de la classe Point donnée précédemment on peut déclarer des variables de cette classe en écrivant 8 : Point a, b, *pt; // deux points et un pointeur de point Dans un contexte où le droit de faire un tel accès est acquis (cf. section 2.2.3) l accès aux membres du point a s écrit : a.x = 0; d = a.distance(b); // un accès bien écrit au membre x du point a // un appel bien écrit de la fonction distance de l objet a Si on suppose que le pointeur pt a été initialisé, par exemple par une expression telle que pt = new Point; alors des accès analogues aux précédents s écrivent : pt->x = 0; d = pt->distance(b); // allocation dynamique d un point // un accès bien écrit au membre x du point pointé par pt // un appel de la fonction distance de l objet pointé par pt A propos de l accès à un membre d un objet, deux questions se posent. Il faut comprendre qu elles sont tout à fait indépendantes l une de l autre : l accès est-il bien écrit? c est-à-dire, désigne-t-il bien le membre voulu de l objet voulu? cet accès est-il légitime? c est-à-dire, dans le contexte où il est écrit, a-t-on le droit d accès sur le membre en question? La question des droits d accès est traitée à la section Dans la plupart des langages orientés objets, les fonctions membres sont appelées méthodes. 7 Dans beaucoup de langages orientés objets, les données membres sont appelées variables d instance et aussi, sous certaines conditions, propriétés 8 Notez que, une fois la classe déclarée, il n est pas obligatoire d écrire class devant Point pour y faire référence. 9

10 2.2.2 Accès à ses propres membres, accès à soi-même Quand des membres d un objet apparaissent dans une expression écrite dans une fonction du même objet on dit que ce dernier fait un accès à ses propres membres. On a droit dans ce cas à une notation simplifiée : on écrit le membre tout seul, sans expliciter l objet en question. C est ce que nous avons fait dans les fonctions de la classe Point : class Point { void afficher() { cout << ( << x <<, << y << ) ; ; Dans la fonction afficher, les membres x et y dont il question sont ceux de l objet à travers lequel on aura appelé cette fonction. Autrement dit, lors d un appel comme unpoint.afficher(); le corps de cette fonction sera équivalent à cout << ( << unpoint.x <<, << unpoint.y << ) ; Accès à soi-même. Il arrive que dans une fonction membre d un objet on doive faire référence à l objet (tout entier) à travers lequel on a appelé la fonction. Il faut savoir que dans une fonction membre 9 on dispose de la pseudo variable this qui représente un pointeur vers l objet en question. Par exemple, la fonction afficher peut s écrire de manière équivalente, mais cela n a aucun intérêt : void afficher() { cout << ( << this->x <<, << this->y << ) ; Pour voir un exemple plus utile d utilisation de this imaginons qu on nous demande d ajouter à la classe Point deux fonctions booléennes, une pour dire si deux points sont égaux, une autre pour dire si deux points sont le même objet. Dans les deux cas le deuxième point est donné par un pointeur : class Point { bool pointegal(point *pt) { return pt->x == x && pt->y == y; bool memepoint(point *pt) { return pt == this; ; Membres publics et privés Par défaut, les membres des classes sont privés. Les mots clés public et private permettent de modifier les droits d accès des membres : class nom { les membres déclarés ici sont privés les membres déclarés ici sont publics private: les membres déclarés ici sont privés etc. ; 9 Sauf dans le cas d une fonction membre statique, voir la section

11 Les expressions et private: peuvent apparaître un nombre quelconque de fois dans une classe. Les membres déclarés après private: (resp. ) sont privés (resp. publics) jusqu à la fin de la classe, ou jusqu à la rencontre d une expression (resp. private:). Un membre public d une classe peut être accédé partout où il est visible ; un membre privé ne peut être accédé que depuis une fonction membre de la classe (les notions de membre protégé, cf. section 4.2.1, et de classes et fonctions amies, cf. section 2.9, nuanceront cette affirmation). Si p est une expression de type Point : dans une fonction qui n est pas membre ou amie de la classe Point, les expressions p.x ou p.y pourtant syntaxiquement correctes et sans ambiguïté, constituent des accès illégaux aux membres privés x et y de la classe Point, les expressions p.afficher() ou p.placer(u, v) sont des accès légaux aux membres publics afficher et placer, qui se résolvent en des accès parfaitement légaux aux membres p.x et p.y Encapsulation au niveau de la classe Les fonctions membres d une classe ont le droit d accéder à tous les membres de la classe : deux objets de la même classe ne peuvent rien se cacher. Par exemple, le programme suivant montre notre classe Point augmentée d une fonction pour calculer la distance d un point à un autre : class Point { void afficher() { cout << ( << x <<, << y << ) ; void placer(int a, int b) { validation des valeurs de a et b; x = a; y = b; double distance(point autrepoint) { int dx = x - autrepoint.x; int dy = y - autrepoint.y; return sqrt(dx * dx + dy * dy); private: int x, y; ; Lors d un appel tel que p.distance(q) l objet p accède aux membres privés x et y de l objet q. On dit que C++ pratique l encapsulation au niveau de la classe, non au niveau de l objet. On notera au passage que, contrairement à d autres langages orientés objets, en C++ encapsuler n est pas cacher mais interdire. Les usagers d une classe voient les membres privés de cette dernière, mais ne peuvent pas les utiliser Structures Une structure est la même chose qu une classe mais, par défaut, les membres y sont publics. Sauf pour ce qui touche cette question, tout ce qui sera dit dans la suite à propos des classes s appliquera donc aux structures : struct nom { les membres déclarés ici sont publics private: les membres déclarés ici sont privés les membres déclarés ici sont publics etc. ; 2.3 Définition des classes Définition séparée et opérateur de résolution de portée Tous les membres d une classe doivent être au moins déclarés à l intérieur de la formule classnom{ ; qui constitue la déclaration de la classe. 11

12 Cependant, dans le cas des fonctions, aussi bien publiques que privées, on peut se limiter à n écrire que leur en-tête à l intérieur de la classe et définir le corps ailleurs, plus loin dans le même fichier ou bien dans un autre fichier. Il faut alors un moyen pour indiquer qu une définition de fonction, écrite en dehors de toute classe, est en réalité la définition d une fonction membre d une classe. Ce moyen est l opérateur de résolution de portée, dont la syntaxe est NomDeClasse:: Par exemple, voici notre classe Point avec la fonction distance définie séparément : class Point { double distance(point autrepoint); Il faut alors, plus loin dans le même fichier ou bien dans un autre fichier, donner la définition de la fonction promise dans la classe Point. Cela s écrit : double Point::distance(Point autrepoint) { int dx = x - autrepoint.x; int dy = y - autrepoint.y; return sqrt(dx * dx + dy * dy); ; Définir les fonctions membres à l extérieur de la classe allège la définition de cette dernière et la rend plus compacte. Mais la question n est pas qu esthétique, il y a une différence de taille : les fonctions définies à l intérieur d une classe sont implicitement qualifiées en ligne (cf. section 1.4). Conséquence : la plupart des fonctions membres seront définies séparément. Seules les fonctions courtes, rapides et fréquemment appelées mériteront d être définies dans la classe Fichier d en-tête et fichier d implémentation En programmation orientée objets, programmer c est définir des classes. Le plus souvent ces classes sont destinées à être utilisées dans plusieurs programmes, présents et à venir 10. Se pose alors la question : comment disposer le code d une classe pour faciliter son utilisation? Voici comment on procède généralement : les définitions des classes se trouvent dans des fichiers en-tête (fichiers.h,.hpp, etc.), chacun des ces fichiers en-tête contient la définition d une seule classe ou d un groupe de classes intimement liées ; par exemple, la définition de notre classe Point pourrait constituer un fichier Point.h les définitions des fonctions membres qui ne sont pas définies à l intérieur de leurs classes sont écrites dans des fichiers sources (fichiers.cpp ou.cp ), aux programmeurs utilisateurs de ces classes sont distribués : les fichiers.h le fichiers objets résultant de la compilation des fichiers.cpp Par exemple, voici les fichiers correspondants à notre classe Point (toujours très modeste) : Fichier Point.h : class Point { void placer(int a, int b) { validation de a et b x = a; y = b; double distance(point autrepoint); private: int x, y; ; 10 La réutilisabilité du code est une des motivations de la méthodologie orientée objets. 12

13 Fichier Point.cpp : #include "Point.h" #include <math.h> double Point::distance(Point autrepoint) { int dx = x - autrepoint.x; int dy = y - autrepoint.y; return sqrt(dx * dx + dy * dy); La compilation du fichier Point.cpp produira un fichier objet (nommé généralement Point.o ou Point.obj). Dans ces conditions, la distribution de la classe Point sera composée des deux fichiers Point.h et Point.obj, ce dernier ayant éventuellement été transformé en un fichier bibliothèque (nommé alors Point.lib ou quelque chose comme ça). Bien entendu, tout programme utilisateur de la classe Point devra comporter la directive #include "Point.h" et devra, une fois compilé, être relié au fichier Point.obj ou Point.lib. 2.4 Constructeurs Définition de constructeurs Un constructeur d une classe est une fonction membre spéciale qui : a le même nom que la classe, n indique pas de type de retour, ne contient pas d instruction return. Le rôle d un constructeur est d initialiser un objet, notamment en donnant des valeurs à ses données membres. Le constructeur n a pas à s occuper de trouver l espace pour l objet ; il est appelé (immédiatement) après que cet espace ait été obtenu, et cela quelle que soit la sorte d allocation qui a été faite : statique, automatique ou dynamique, cela ne regarde pas le constructeur. Exemple : class Point { Point(int a, int b) { validation des valeurs de a et b x = a; y = b; autres fonctions membres private: int x, y; ; Un constructeur de la classe est toujours appelé, explicitement (voir ci-dessous) ou implicitement, lorsqu un objet de cette classe est créé, et en particulier chaque fois qu une variable ayant cette classe pour type est définie. C est le couple définition de la variable + appel du constructeur qui constitue la réalisation en C++ du concept création d un objet. L intérêt pour le programmeur est évident : garantir que, dès leur introduction dans un programme, tous les objets sont garnis et cohérents, c est-à-dire éviter les variables indéfinies, au contenu incertain. Une classe peut posséder plusieurs constructeurs, qui doivent alors avoir des signatures différentes : 13

14 class Point { Point(int a, int b) { validation de a et b x = a; y = b; Point(int a) { validation de a x = a; y = 0; Point() { x = y = 0; private: int x, y; ; L emploi de paramètres avec des valeurs par défaut permet de grouper des constructeurs. La classe suivante possède les mêmes constructeurs que la précédente : class Point { Point(int a = 0, int b = 0) { validation de a et b x = a; y = b; private: int x, y; ; Comme les autres fonctions membres, les constructeurs peuvent être déclarés dans la classe et définis ailleurs. Ainsi, la classe précédente pourrait s écrire également et, ailleurs : class Point { Point(int a = 0, int b = 0); private: int x, y; ; Point::Point(int a, int b) { validation de a et b x = a; y = b; Deux remarques générales. 1. Comme l exemple ci-dessus le montre, lorsqu une fonction fait l objet d une déclaration et d une définition séparées, comme le constructeur Point, les éventuelles valeurs par défaut des argument concernent la déclaration, non la définition. 2. Lorsqu une fonction fait l objet d une déclaration et d une définition séparées, les noms des arguments ne sont utiles que pour la définition. Ainsi, la déclaration du constructeur Point ci-dessus peut s écrire également : class Point { Point(int = 0, int = 0); ; 14

15 2.4.2 Appel des constructeurs Un constructeur est toujours appelé lorsqu un objet est crée, soit explicitement, soit implicitement. Les appels explicites peuvent être écrits sous deux formes : Point a(3, 4); Point b = Point(5, 6); Dans le cas d un constructeur avec un seul paramètre, on peut aussi adopter une forme qui rappelle l initialisation des variables de types primitifs (à ce propos voir aussi la section 3.3.1) : Point e = 7; // équivaut à : Point e = Point(7) Un objet alloué dynamiquement est lui aussi toujours initialisé, au mois implicitement. Dans beaucoup de cas il peut, ou doit, être initialisé explicitement. Cela s écrit : Point *pt; pt = new Point(1, 2); Les constructeurs peuvent aussi être utilisés pour initialiser des objets temporaires, anonymes. En fait, chaque fois qu un constructeur est appelé, un objet nouveau est crée, même si cela ne se passe pas à l occasion de la définition d une variable. Par exemple, deux objets sans nom, représentant les points (0,0) et (3,4), sont créés dans l instruction suivante 11 : cout << Point(0, 0).distance(Point(3, 4)) << "\n"; Note. L appel d un constructeur dans une expression comportant un signe = peut prêter à confusion, à cause de sa ressemblance avec une affectation. Or, en C++, l initialisation et l affectation sont deux opérations distinctes, du moins lorsqu elles concernent des variables d un type classe : l initialisation consiste à donner une première valeur à une variable au moment où elle commence à exister ; l affectation consiste à remplacer la valeur courante d une variable par une autre valeur ; les opérations mises en œuvre par le compilateur, constructeur dans un cas, opérateur d affectation dans l autre, ne sont pas les mêmes. Comment distinguer le = d une affectation de celui d une initialisation? Grossièrement, lorsque l expression commence par un type, il s agit d une définition et le signe = correspond à une initialisation. Exemple : Point a = Point(1, 2); // Initialisation de a Cette expression crée la variable a et l initialise en rangeant dans a.x et a.y les valeurs 1 et 2. En revanche, lorsque l expression ne commence pas par un type, il s agit d une affectation. Exemple : Point a; a = Point(1, 2); // Affectation de a L expression ci-dessus est une affectation ; elle crée un point anonyme de coordonnées (1,2) et le recopie sur la variable a en remplacement de la valeur courante de cette variable, construite peu avant. On arrive au même résultat que précédemment, mais au prix de deux initialisations et une affectation à la place d une seule initialisation Constructeur par défaut Le constructeur par défaut est un constructeur qui peut être appelé sans paramètres : ou bien il n en a pas, ou bien tous ses paramètres ont des valeurs par défaut. Il joue un rôle remarquable, car il est appelé chaque fois qu un objet est créé sans qu il y ait appel explicite d un constructeur, soit que le programmeur ne le juge pas utile, soit qu il n en a pas la possibilité : Point x; Point t[10]; Point *p = new Point; Point *q = new Point[10]; // équivaut à : Point x = Point() // produit 10 appels de Point() // équivaut à : p = new Point() // produit 10 appels de Point() Synthèse d un constructeur par défaut. Puisque tout objet doit être initialisé lors de sa création, si le programmeur écrit une classe sans aucun constructeur, alors le compilateur synthétise un constructeur par défaut comme ceci : 11 Ces objets anonymes ne pouvant servir à rien d autre dans ce programme, ils seront détruits lorsque cette instruction aura été exécutée. 15

16 si la classe n a ni objet membre, ni fonction virtuelle, ni classe de base (c est le cas de notre classe Point), alors le constructeur synthétisé est le constructeur trivial, qui consiste à ne rien faire. Les données membres seront créées comme elles l auraient été en C, c est-à-dire initialisées par zéro s il s agit d une variable globale, laissées indéterminées s il s agit d une variable locale ou dynamique, si la classe a des objets membres ou des classes de base, alors le constructeur synthétisé produit l appel du constructeur par défaut de chaque objet membre et de chaque classe de base. Attention. Si au moins un constructeur est défini pour une classe, alors aucun constructeur par défaut n est synthétisé par le compilateur. Par conséquent, ou bien l un des constructeurs explicitement définis est un constructeur par défaut, ou bien toute création d un objet devra expliciter des valeurs d initialisation Constructeur par copie (clonage) Le constructeur par copie d une classe C est un constructeur dont le premier paramètre est de type C & (référence sur un C ) ou const C & (référence sur un C constant) et dont les autres paramètres, s ils existent, ont des valeurs par défaut. Ce constructeur est appelé lorsqu un objet est initialisé en copiant un objet existant. Cela arrive parfois explicitement, mais souvent implicitement, notamment chaque fois qu un objet est passé comme paramètre par valeur à une fonction ou rendu comme résultat par valeur (c.-à-d. autre qu une référence) d une fonction. Si le programmeur n a pas défini de constructeur de copie pour une classe, le compilateur synthétise un constructeur par copie consistant en la recopie de chaque membre d un objet dans le membre correspondant de l autre objet. Si ces membres sont de types primitifs ou des pointeurs, cela revient à faire la copie bit à bit d un objet sur l autre. A titre d exemple le programme suivant introduit une nouvelle variété de point ; à chacun est associée une étiquette qui est une chaîne de caractères : class PointNomme { PointNomme(int a, int b, char *s = "") { x = a; y = b; label = new char[strlen(s) + 1]; strcpy(label, s); private: int x, y; char *label; ; x y label Un texte Fig. 1 Un point avec étiquette La figure 1 représente la structure de ces objets. Lorsqu un objet comporte des pointeurs, comme ici, l information qu il représente (appelons-la l objet logique ) ne se trouve pas entièrement incluse dans l espace contigu que le compilateur connaît (l objet technique ), car des morceaux d information (dans notre exemple le texte de l étiquette) se trouvent à d autres endroits de la mémoire. Ainsi, la copie bit à bit que fait le compilateur peut être inadaptée à de tels objets. La figure 2 montre le résultat de la copie bit à bit d un objet Point telle que la produirait, avec l actuelle définition de la classe, une affectation telle que b = a; (a et b sont des variables de type Point). Bien entendu, la copie du pointeur n a pas dupliqué la chaîne pointée : les deux objets, l original et la copie, partagent la même chaîne. La plupart du temps ce partage n est pas souhaitable, car difficile à gérer et dangereux : toute modification de l étiquette d un des deux points se répercutera immédiatement sur l autre. Pour résoudre ce problème il faut équiper notre classe d un constructeur par copie : 16

17 x y label a Un texte x y label b Fig. 2 Copie superficielle d un objet class PointNomme { PointNomme(PointNomme &p) { x = p.x; y = p.y; label = new char[strlen(p.label) + 1]; strcpy(label, p.label); ; Maintenant, la copie d un point entraînera la duplication effective de la chaîne de caractères pointée, comme sur la figure 3. x y label a Un texte x y label b Un texte Fig. 3 Copie profonde 2.5 Construction des objets membres Lorsque des membres d une classe sont à leur tour d un type classe on dit que la classe a des objets membres. L initialisation d un objet de la classe nécessite alors l initialisation de ces objets membres. Il en est toujours ainsi, indépendamment du fait que l on emploie ou non un constructeur explicite, et qu à son tour ce constructeur appelle ou non explicitement des constructeurs des objets membres. Lorsque les objets membres n ont pas de constructeurs par défaut, une syntaxe spéciale 12 permet de préciser les arguments des constructeurs des membres : NomDeLaClasse(paramètres) : membre(paramètres), membre(paramètres) { corps du constructeur A titre d exemple, imaginons que notre classe Point ne possède pas de constructeur sans arguments, et qu on doive définir une classe Segment ayant deux points pour membres (un segment est déterminé par deux points). Voici comment on devra écrire son constructeur : class Segment { Point origine, extremite; int epaisseur; Segment(int ox, int oy, int ex, int ey, int ep) : origine(ox, oy), extremite(ex, ey) { epaisseur = ep; ; Note. Si la classe Point avait eu un constructeur sans arguments, le mauvais constructeur suivant aurait quand-même fonctionné 12 A titre d exercice on vérifiera que, sans cette syntaxe spéciale, la construction des objets membres serait impossible. 17

18 class Segment { Segment(int ox, int oy, int ex, int ey, int ep) { ; origine = Point(ox, oy); extremite = Point(ex, ey); epaisseur = ep; // Version erronée mais il faut comprendre que cette version est très maladroite, car faite de deux affectations (les deux lignes qui forment le corps du constructeur ne sont pas des déclarations). Ainsi, au lieu de se limiter à initialiser les membres origine et extrémité, on procède successivement à la construction de origine et extrémité en utilisant le constructeur sans arguments de la classe Point, la construction de deux points anonymes, initialisés avec les valeurs de ox, oy, ex et ey, l écrasement des valeurs initiales de origine et extrémité par les deux points ainsi construits. Note. La syntaxe spéciale pour l initialisation des objets membres peut être utilisée aussi pour initialiser les données membres de types primitifs. Par exemple, le constructeur de Segment précédent peut aussi s écrire : class Segment { Segment(int ox, int oy, int ex, int ey, int ep) : origine(ox, oy), extremite(ex, ey), epaisseur(ep) { ; 2.6 Destructeurs De la même manière qu il y a des choses à faire pour initialiser un objet qui commence à exister, il y a parfois des dispositions à prendre lorsqu un objet va disparaître. Un destructeur est une fonction membre spéciale. Il a le même nom que la classe, précédé du caractère ~. Il n a pas de paramètre, ni de type de retour. Il y a donc au plus un destructeur par classe. Le destructeur d une classe est appelé lorsqu un objet de la classe est détruit, juste avant que la mémoire occupée par l objet soit récupérée par le système. Par exemple, voici le destructeur qu il faut ajouter à notre classe PointNommé. Sans ce destructeur, la destruction d un point n entraînerait pas la libération de l espace alloué pour son étiquette : class PointNomme { ~PointNomme() { delete [] label; ; Notez que le destructeur n a pas à s inquiéter de restituer l espace occupé par l objet technique lui-même, formé, ici, par les variables x, y et label (le pointeur, non la chaîne pointée). Cette restitution dépend du type de mémoire que l objet occupe, statique, automatique ou dynamique, et ne regarde pas le destructeur, de la même manière que son allocation ne regardait pas le constructeur qui a initialisé l objet. Synthèse du destructeur. Si le programmeur n a pas écrit de destructeur pour une classe, le compilateur en synthétise un, de la manière suivante : si la classe n a ni objets membres ni classes de base (cf. section 4), alors il s agit du destructeur trivial qui consiste à ne rien faire, si la classe a des classes de base ou des objets membres, le destructeur synthétisé consiste à appeler les destructeurs des données membres et des classes de base, dans l ordre inverse de l appel des constructeurs correspondants. 18

19 2.7 Membres constants Données membres constantes Une donnée membre d une classe peut être qualifiée const. Il est alors obligatoire de l initialiser lors de la construction d un objet, et sa valeur ne pourra par la suite plus être modifiée. A titre d exemple voici une nouvelle version de la classe Segment, dans laquelle chaque objet reçoit, lors de sa création, un numéro de série qui ne doit plus changer au cours de la vie de l objet : class Segment { Point origine, extremite; int epaisseur; const int numerodeserie; Segment(int x1, int y1, int x2, int y2, int ep, int num); ; Constructeur, version erronée : Segment::Segment(int x1, int y1, int x2, int y2, int ep, int num) : origine(x1, y1), extremite(x2, y2) { epaisseur = ep; numerodeserie = num; // ERREUR : tentative de modification d une constante Constructeur, version correcte, en utilisant la syntaxe de l initialisation des objets membres : Segment::Segment(int x1, int y1, int x2, int y2, int ep, int num) : origine(x1, y1), extremite(x2, y2), numerodeserie(num) { epaisseur = ep; Fonctions membres constantes Le mot const placé à la fin de l en-tête d une fonction membre indique que l état de l objet à travers lequel la fonction est appelée n est pas changé du fait de l appel. C est une manière de déclarer qu il s agit d une fonction de consultation de l objet, non d une fonction de modification : class Point { void placer(int a, int b); float distance(point p) const; ; // modifie l objet // ne modifie pas l objet A l intérieur d une fonction const d une classe C le pointeur this est de type const C * const (pointeur constant vers un C constant) : l objet pointé par this ne pourra pas être modifié. Cela permet au compilateur d autoriser certains accès qui, sans cela, auraient été interdits. Par exemple, examinons la situation suivante : void unefonction(const Point a) { Point b; double d = a.distance(b); la qualification const de la fonction distance est indispensable pour que l expression précédente soit acceptée par le compilateur. C est elle seule, en effet, qui garantit que le point a, contraint à rester constant, ne sera pas modifié par l appel de distance. Il est conseillé de qualifier const toute fonction qui peu l être : comme l exemple précédent le montre, cela élargit son champ d application. Coexistence des fonctions constantes et non constantes. La qualification const d une fonction membre fait partie de sa signature. Ainsi, on peut surcharger une fonction membre non constante par une fonction membre constante ayant, à part cela, le même en-tête. La fonction non constante sera appelée sur les objets non constants, la fonction constante sur les objets constants. 19

20 On peut utiliser cette propriété pour écrire des fonctions qui n effectuent pas le même traitement ou qui ne rendent pas le même type de résultat lorsqu elles sont appelées sur un objet constant et lorsqu elles sont appelées sur un objet non constant. Exemple (se rappeler que le résultat rendu par une fonction ne fait pas partie de sa signature) : class Point { int x, y; int X() const { return x; int Y() const { return y; int& X() { return x; int& Y() { return y; ; Avec la déclaration précédente, les fonctions X et Y sont sécurisées : sur un objet constant elles ne permettent que la consultation, sur un objet non constant elles permettent la consultation et la modification : const Point a(2, 3); Point b(4,5); int r; r = a.x(); // Oui a.x() = r; // ERREUR ( a.x() rend une valeur) r = b.x(); // Oui b.x() = r; // Oui ( b.x() rend une référence) 2.8 Membres statiques Chaque objet d une classe possède son propre exemplaire de chaque membre ordinaire (bientôt nous dirons membre non statique) de la classe : pour les données membres, cela signifie que de la mémoire nouvelle est allouée lors de la création de chaque objet ; pour les fonctions membres, cela veut dire qu elles ne peuvent être appelées qu en association avec un objet (on n appelle pas la fonction f mais la fonction f sur l objet x ). A l opposé de cela, les membres statiques, signalés par la qualification static précédant leur déclaration, sont partagés par tous les objets de la classe. De chacun il n existe qu un seul exemplaire par classe, quel que soit le nombre d objets de la classe. Les données et fonctions membres non statiques sont donc ce que dans d autres langages orientés objets on appelle variables d instance et méthodes d instance, tandis que les données et fonctions statiques sont appelées dans ces langages variables de classe et méthodes de classe. La visibilité et les droits d accès des membres statiques sont régis par les mêmes règles que les membres ordinaires Données membres statiques class Point { int x, y; static int nombredepoints; Point(int a, int b) { x = a; y = b; nbrpoints++; ; Chaque objet Point possède ses propres exemplaires des membres x et y mais, quel que soit le nombre de points existants à un moment donné, il existe un seul exemplaire du membre nombredepoints. Initialisation. La ligne mentionnant nombredepoints dans la classe Point est une simple annonce, comme une déclaration extern du langage C. Il faut encore créer et initialiser cette donnée membre (ce qui, pour une donnée membre non statique, est fait par le constructeur lors de la création de chaque objet). Cela 20