Le langage C++

À 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 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;         // 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.

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 chaines de caractères :

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 chaines :

age("Amélie") = 20;

ou encore

age("Benjamin")++;

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 :

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)
  ...
}

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);

• 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.

²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.

³C'est un exemple simpliste, pour faire court nous n'y avons pas traité le cas de l'absence de la chaine cherchée.

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 :

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;         // un accès bien écrit au membre x du point a
d = a.distance(b);     // 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;     // allocation dynamique d'un point

alors des accès analogues aux précédents s'écrivent :

pt->x = 0;         // un accès bien écrit au membre x du point pointé par pt
d = pt->distance(b);   // un appel de la fonction distance de l'objet pointé par pt

À 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 2.2.3.

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.

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 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;
  }
  ...
};

⁹Sauf dans le cas d'une fonction membre statique, voir la section 2.8.

Par défaut, les membres des classes sont privés. Les mot-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
public:
  les membres déclarés ici sont publics
private:
  les membres déclarés ici sont privés
etc.
};

Les expressions public: et private: peuvent apparaitre un nombre quelconque de fois dans une classe. Les membres déclarés après private: (resp. public:) sont privés (resp. publics) jusqu'à la fin de la classe, ou jusqu'à la rencontre d'une expression public: (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.

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 {
public:
  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 objet, 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.

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
public:
  les membres déclarés ici sont publics
etc.
};

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.

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 {
public:
  ...
  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.

En programmation orientée objet, « 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. 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 fichier objet 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 {
  public:
    void placer(int a, int b) {
      validation de a et b
      x = a; y = b;
  }
  double distance(Point autrePoint);
private:
  int x, y;
};

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.

¹⁰La réutilisabilité du code est une des motivations de la méthodologie orientée objet.

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 {
public:
  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 :

class Point {
public:
  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 {
public:
  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

class Point {
public:
  Point(int a = 0, int b = 0);
  ...
private:
  int x, y;
};

et, ailleurs :

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 arguments 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);
    ...
};

Un constructeur est toujours appelé lorsqu'un objet est créé, 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éé, 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 :

cout << Point(0, 0).distance(Point(3, 4)) << "\n";

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.

¹¹Ces objets anonymes ne pouvant servir à rien d'autre dans ce programme, ils seront détruits lorsque cette instruction aura été exécutée.

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;           // équivaut à : Point x = Point()
Point t[10];         // produit 10 appels de Point()
Point *p = new Point;     // équivaut à : p = new Point()
Point *q = new Point[10];   // 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 :

• 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.

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.

À titre d'exemple le programme suivant introduit une nouvelle variété de point ; à chacun est associée une étiquette qui est une chaine de caractères :

class PointNomme {
public:
  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;
};

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 connait (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 chaine pointée : les deux objets, l'original et la copie, partagent la même chaine. 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 :

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 entrainera la duplication effective de la chaine de caractères pointée, comme sur la figure 3.

¹¹Ces objets anonymes ne pouvant servir a rien d'autre dans ce programme, ils seront détruits lorsque cette instruction aura été exécutée.

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.

À 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;
public:
    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;
}

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);     // modifie l'objet
  float distance(Point p) const;   // ne modifie pas l'objet
  ...
};

À 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 peut 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.

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;
public:
  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)

class Point {
  int x, y;
public:
  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 se fait par une formule analogue à une définition de variable, écrite dans la portée globale, même s'il s'agit de membres privés :

int Point::nombreDePoints = 0;

(la ligne ci-dessus doit être écrite dans un fichier « .cpp », non dans un fichier « .h ») L'accès à un membre statique depuis une fonction membre de la même classe s'écrit comme l'accès à un membre ordinaire (voyez

l'accès à nombreDePoints fait dans le constructeur Point ci-dessus).

L'accès à un membre statique depuis une fonction non membre peut se faire à travers un objet, n'importe lequel, de la classe :

Point a, b, c;
...
cout << a.nombreDePoints << "\n";

Mais, puisqu'il y a un seul exemplaire de chaque membre statique, l'accès peut s'écrire aussi indépendamment de tout objet, par une expression qui met bien en évidence l'aspect « variable de classe » des données membres statiques :

cout << Point::nombreDePoints << "\n";

Une fonction membre statique n'est pas attachée à un objet. Par conséquent :

• elle ne dispose pas du pointeur this ;
• de sa classe, elle ne peut référencer que les fonctions et les membres statiques.

Par exemple, voici la classe Point précédente, dans laquelle le membre nombreDePoints a été rendu privé pour en empêcher toute modification intempestive. Il faut donc fournir une fonction pour en consulter la valeur, nous l'avons appelée combien :

class Point {
  int x, y;
  static int nombreDePoints;
public:
  static int combien() {
  return nombreDePoints;
  }
  Point(int a, int b) {
    x = a; y = b;
    nbrPoints++;
  }
};

Pour afficher le nombre de points existants, on devra maintenant écrire une expression comme (a étant de type Point) :

cout << a.combien() << "\n";

ou, encore mieux, une expression qui ne fait pas intervenir de point particulier :

cout << Point::combien() << "\n";

Une fonction amie d'une classe C est une fonction qui, sans être membre de cette classe, a le droit d'accéder à tous ses membres, aussi bien publics que privés.

Une fonction amie doit être déclarée ou définie dans la classe qui accorde le droit d'accès, précédée du mot réservé friend. Cette déclaration doit être écrite indifféremment parmi les membres publics ou parmi les membres privés :

class Tableau {
  int *tab, nbr;
  friend void afficher(const Tableau &);
public:
  Tableau(int nbrElements);
  ...
};

et, plus loin, ou bien dans un autre fichier :

void afficher(const Tableau &t) {
  cout << '[';
  for (int i = 0; i < t.nbr; i++)
    cout << ' ' << t.tab[i];
  cout << ]" ;"
}

Les exemples précédents ne montrent pas l'utilité des fonctions amies, ce n'est pas une chose évidente. En effet, dans la plupart des cas, une fonction amie peut avantageusement être remplacée par une fonction membre :

class Tableau {
  int *tab, nbr;
public:
  void afficher() const; //maintenant c'est une fonction membre
  ...
};

avec la définition :

void Tableau::afficher() {
  cout << '[';
  for (int i = 0; i < nbr; i++)
    cout << ' ' << tab[i];
  cout << ]" ;"
}

Il y a cependant des cas de figure où une fonction doit être nécessairement écrite comme une amie d'une classe et non comme un membre ; un de ces cas est celui où la fonction doit, pour des raisons diverses, être membre d'une autre classe. Imaginons, par exemple, que la fonction afficher doive écrire les éléments d'un objet Tableau dans un certain objet Fenêtre :

class Tableau;     // ceci « promet » la classe Tableau
 
class Fenetre {
  ostream &fluxAssocie;
public:
  void afficher(const Tableau &);
  ...
};
 
class Tableau {
  int *tab, nbr;
public:
  friend void Fenetre::afficher(const Tableau&);
  ...
};

Maintenant, la fonction afficher est membre de la classe Fenetre et amie de la classe Tableau : elle a tous les droits sur les membres privés de ces deux classes, et son écriture s'en trouve facilitée :

void Fenetre::afficher(const Tableau &t) {
  for (int i = 0; i < t.nbr; i++)
    fluxAssocie << t.tab[i];
}

Une classe amie d'une classe C est une classe qui a le droit d'accéder à tous les membres de C. Une telle classe doit être déclarée dans la classe C (la classe qui accorde le droit d'accès), précédée du mot réservé friend, indifféremment parmi les membres privés ou parmi les membres publics de C.

Exemple : les deux classes Maillon et Pile suivantes implémentent la structure de données pile (structure « dernier entré premier sorti ») d'entiers :

class Maillon {
  int info;
  Maillon *suivant;
  Maillon(int i, Maillon *s) {
    info = i; suivant = s;
  }
  friend class Pile;
};
 
class Pile {
  Maillon *top;
public:
  Pile() {
    top = 0;
  }
  bool vide() {
    return top == 0;
  }
  void empiler(int x) {
    top = new Maillon(x, top);
  }
  int sommet() {
    return top->info;
  }
  void depiler() {
    Maillon *w = top;
    top = top->suivant;
    delete w;
  }
};

On notera la particularité de la classe Maillon ci-dessus : tous ses membres sont privés, et la classe Pile est son amie (on dit que Maillon est une classe « esclave » de la classe Pile). Autrement dit, seules les piles ont le droit de créer et de manipuler des maillons ; le reste du système n'utilise que les piles et leurs opérations publiques, et n'a même pas à connaitre l'existence des maillons.

Exemple d'utilisation :

Pile p;
int x;
 
cout << "? "; cin >> x;
while (x >= 0) {
  p.empiler(x);
  cin >> x;
}
 
while (! p.vide()) {
  cout << p.sommet() << ' ';
  p.depiler();
}

La relation d'amitié n'est pas transitive, « les amis de mes amis ne sont pas mes amis ». À l'évidence, la notion d'amitié est une entorse aux règles qui régissent les droits d'accès ; elle doit être employée avec une grande modération, et uniquement pour permettre l'écriture de composants intimement associés d'un programme, comme les classes Maillon et Pile de notre exemple.

Si la fonction operator² est membre d'une classe, elle doit comporter un paramètre de moins que la pluralité de l'opérateur : le premier opérande sera l'objet à travers lequel la fonction a été appelée. Ainsi, sauf quelques exceptions :

• « obj² » ou « ²obj » équivalent à « obj .operator²() »
• « obj1 ² obj2 » équivaut à « obj1.operator²(obj2) »

Exemple :

class Point {
  int x, y;
public:
  Point(int = 0, int = 0);
  int X() const { return x; }
  int Y() const { return y; }
  Point operator+(const Point) const;   //surcharge de + par une fonction membre
  ...
};
 
Point Point::operator+(const Point q) const {
  return Point(x + q.x, y + q.y);
}

Emploi :

Point p, q, r;
...
r = p + q;       // compris comme : r = p.operator+(q);

Si la fonction operator² n'est pas membre d'une classe, alors elle doit avoir un nombre de paramètres égal à la pluralité de l'opérateur. Dans ce cas :

• « obj² » ou « ²obj » équivalent à « operator²(obj ) »
• « obj1 ² obj2 » équivaut à « operator²(obj1, obj2) »

Exemple :

Point operator+(const Point p, const Point q) {     // surcharge de + par une
  return Point(p.X() + q.X(), p.Y() + q.Y());     // fonction non membre
}

Emploi :

Point p, q, r;
...
r = p + q;         // compris maintenant comme : r = operator+(p, q);

Point p, q, r;
int x, y;

Surcharge de l'opérateur + par une fonction membre :

r = p + q;     // Oui : r = p.operator+(q);
r = p + y;     // Oui : r = p.operator+(Point(y));
r = x + q;     // Erreur : x n'est pas un objet

Surcharge de l'opérateur + par une fonction non membre :

r = p + q;     // Oui : r = operator+(p, q);
r = p + y;     // Oui : r = operator+(p, Point(y));
r = x + q;     // Oui : r = operator+(Point(p), q);

class Point {
  int x, y;
public:
  Point(int = 0, int = 0);
  friend Point operator+(const Point, const Point);
  ...
};
 
Point operator+(const Point p, Point q) {
  return Point(p.x + q.x, p.y + q.y);
}

L'opérateur << peut être utilisé pour « injecter » des données dans un flux de sortie, ou ostream (cf. section 1.8). D'une part, l'auteur de la classe ostream a défini des surcharges de <<, probablement par des fonctions membres, pour les types connus lors du développement de la bibliothèque standard :

class ostream {
  ...
public:
  ...
  ostream& operator<<(int);
  ostream& operator<<(unsigned int);
  ostream& operator<<(long);
  ostream& operator<<(unsigned long);
  ostream& operator<<(double);
  ostream& operator<<(long double);
  etc.  
  ...
};

D'autre part, le programmeur qui souhaite étendre << aux objets d'une classe qu'il est en train de développer ne peut plus ajouter des membres à la classe ostream. Il doit donc écrire une fonction non membre :

ostream& operator<<(ostream& o, const Point p) {
return o << '(' << p.X() << ',' << p.Y() << ')';
}

Parfois (ce n'est pas le cas ici), l'écriture de l'opérateur non membre est plus simple si on en fait une fonction amie des classes des opérandes :

class Point {
  ...
  friend ostream& operator<<(ostream&, const Point);
};
 
ostream& operator<<(ostream &o, const Point p) {
  return o << '(' << p.x << ',' << p.y << ')';
}

Avec cette surcharge de << nos points s'écrivent sur un flux de sortie comme les données primitives :

Point p;
...
cout << "le point trouvé est : " << p << "\n";

On peut de manière analogue surcharger l'opérateur >> afin d'obtenir un moyen simple pour lire des points. Par exemple, si on impose que les points soient donnés sous la forme (x; y), c'est-à-dire par deux nombres séparés par une virgule et encadrés par des parenthèses :

class Point {
  ...
  friend ostream& operator<<(ostream&, const Point);
  friend istream& operator>>(istream&, Point&);
};
 
istream& operator>>(istream& i, Point& p) {
char c;
i >> c;
if (c == '(') {
  cin >> p.x >> c;
  if (c == ',') {
    cin >> p.y >> c;
    if (c == ')')
      return i;
  }
}
cerr << "Erreur de lecture. Programme avorté\n";
exit(-1);
}

Exemple d'utilisation :

void main() {
  Point p;
  cout << "donne un point : ";
  cin >> p;
  cout << "le point donné est : " << p << "\n";
}

Essai de ce programme :

donne un point : ( 2 , 3 )
le point donné est : (2,3)

¹³Appliqué à des données de types primitifs, l'opérateur << exprime, en C++ comme en C, l'opération de décalage de bits vers la gauche

L'affectation entre objets est une opération prédéfinie qui peut être surchargée. Si le programmeur ne le fait pas, tout se passe comme si le compilateur avait synthétisé une opération d'affectation consistant en la recopie membre à membre des objets. S'il s'agit d'une classe sans objets membres, sans classe de base et sans fonction virtuelle, cela donne l'opérateur d'affectation trivial, consistant en la copie bit à bit d'une portion de mémoire sur une autre, comme pour la copie des structures du langage C.

Les raisons qui poussent à surcharger l'opérateur d'affectation pour une classe sont les mêmes que celles qui poussent à écrire un constructeur par copie (cf. section 2.4.4). Très souvent, c'est que la classe possède des « bouts dehors », c'est-à-dire des membres de type pointeur, et qu'on ne peut pas se contenter d'une copie superficielle.

L'opérateur d'affectation doit être surchargé par une fonction membre (en effet, dans une affectation on ne souhaite pas que les opérandes jouent des rôles symétriques).

Reprenons les points munis d'étiquettes qui nous ont déjà servi d'exemple :

class PointNomme {
public:
  PointNomme(int = 0, int = 0, char * = "");
  PointNomme(const PointNomme&);
  ~PointNomme();
private:
  int x, y;
  char *label;
};
 
PointNomme::PointNomme(int a, int b, char *s) {
  x = a; y = b;
  label = new char[strlen(s) + 1];
  strcpy(label, s);
}
 
PointNomme::PointNomme(const PointNomme& p) {
  cout << "PointNomme(const PointNomme&)\n";
  x = p.x; y = p.y;
  label = new char[strlen(p.label) + 1];
  strcpy(label, p.label);
}
 
PointNomme::~PointNomme() {
  cout << "~PointNomme()\n";
  delete [] label;
}

Avec une classe PointNomme définie comme ci-dessus, un programme aussi « inoffensif » que le suivant est erroné (et explosif) :

void main() {
  PointNomme p(0, 0, "Origine"), q;
  q = p;
}

En effet, l'affectation n'ayant pas été surchargée, l'instruction « q = p ; » ne fait qu'une recopie bit à bit de l'objet p dans l'objet q, c'est-à-dire une copie superficielle (voyez la figure 2 à la page 17). À la fin du programme, les objets p et q sont détruits, l'un après l'autre. Or, la destruction d'un de ces objets libère la chaine label et rend l'autre objet incohérent, ce qui provoque une erreur fatale lors de la restitution du second objet.

Voici la surcharge de l'opérateur d'affectation qui résout ce problème. Comme il fallait s'y attendre, cela se résume à une destruction de la valeur courante (sauf dans le cas vicieux où on essaierait d'affecter un objet par lui-même) suivie d'une copie :

class PointNomme {
public:
  PointNomme(int = 0, int = 0, char * = "");
  PointNomme(const PointNomme&);
  PointNomme& operator=(const PointNomme&);
  ~PointNomme();
  ...
};
 
PointNomme& PointNomme::operator=(const PointNomme& p) {
  if (&p != this) {
    delete [] label;
    x = p.x;
    y = p.y;
    label = new char[strlen(p.label) + 1];
    strcpy(label, p.label);
  }
  return *this;
}

Pour convertir une donnée de n'importe quel type, primitif ou classe, vers un type classe il suffit d'employer un constructeur de conversion. Un tel constructeur n'est pas une notion nouvelle, mais simplement un constructeur qui peut être appelé avec un seul argument. Exemple :

class Point {
...
public:
Point(int a) {
x = y = a;
}
...
};

Le programmeur peut appeler explicitement ce constructeur de trois manières différentes :

Point p = Point(2);
Point q(3);     // compris comme Point q = Point(3);
Point r = 4;     // compris comme Point r = Point(4);

La troisième expression ci-dessus fait bien apparaitre l'aspect « conversion » de ce procédé. Il faut savoir qu'un tel constructeur sera aussi appelé implicitement, car le compilateur s'en servira à chaque endroit où, un Point étant requis, il trouvera un nombre. Exemple (vu à la section 3.1.2) :

Point p;
...
r = p + 5;       // compris comme : r = operator+(p, Point(5));

class Point {
...
public:
  explicit Point(int a) {
  x = y = a;
  }
  ...
};

Nouvel essai :

Point p = Point(1); // Ok
Point q = 2; // ERREUR

C étant une classe et T un type, primitif ou non, on définit la conversion de C vers T par une fonction

membre C::operatorT().

Par exemple, les classes Point et Segment suivantes sont munies de conversions int $ Point et Point $ Segment :

struct Point {
  int x, y;
  ...
  Point(int a) {           // conversion int ! Point
    x = a; y = 0;
  }
  operator int() {         // conversion Point ! int
    return abs(x) + abs(y); // par exemple...
  }
};
 
struct Segment {
  Point orig, extr;
  ...
  Segment(Point p)         // conversion Point ! Segment
    : orig(p), extr(p) { }
  operator Point() {         // conversion Segment ! Point
    return Point((orig.x + extr.x) / 2, (orig.y + extr.y) / 2);
  }
};

En plus des membres publics et privés, une classe C peut avoir des membres protégés. Annoncés par le mot-clé protected, ils représentent une accessibilité intermédiaire, car ils sont accessibles par les fonctions membres et amies de C et aussi par les fonctions membres et amies des classes directement dérivées de C.

Les membres protégés sont donc des membres qui ne font pas partie de l'interface de la classe, mais dont on a jugé que le droit d'accès serait nécessaire ou utile aux concepteurs des classes dérivées.

Imaginons, par exemple, qu'on veuille comptabiliser le nombre d'accès faits aux objets de nos classes Tableau et Pile. Il faudra leur ajouter un compteur, qui n'aura pas à être public (ces décomptes ne regardent pas les utilisateurs de ces classes), mais qui devra être accessible aux membres de la classe Pile, si on veut que les accès aux piles qui ne mettent en œuvre aucun membre des tableaux, comme dans vide(), soient bien comptés.

class Tableau {
  int *tab;
  int maxTab;
protected:
  int nbrAcces;
public:
  Tableau(int t) {
    nbrAcces = 0;
    tab = new int[maxTab = t];
  }
  int &operator[](int i) {
    contrôle de la valeur de i
    nbrAcces++;
    return tab[i];
  }
};
 
class Pile : private Tableau {
  int niveau;
public:
  Pile(int t)
    : Tableau(t), niveau(0) { }
  bool vide() {
    nbrAcces++; return niveau == 0;
  }
  void empiler(int x) {
    (*this)[niveau++] = x;
  }
  int depiler() {
    return (*this)[--niveau];
  }
};

En choisissant quel mot-clé indique la dérivation, parmi private, protected ou public, le programmeur détermine l'accessibilité dans la classe dérivée des membres de la classe de base. On notera que :

• cela concerne l'accessibilité des membres, non leur présence (les objets de la classe dérivée contiennent toujours tous les membres de toutes les classes de base) ;
• la dérivation ne peut jamais servir à augmenter l'accessibilité d'un membre.

Conséquence de ces deux points, les objets des classes dérivées ont généralement des membres inaccessibles : les membres privés de la classe de base sont présents dans les objets de la classe dérivée, mais il n'y a aucun moyen d'y faire référence.

Héritage privé. Syntaxe :

class classeDérivée : privateoptionnel classeDeBase { ... }

Le mot-clé private est optionnel, car l'héritage privé est l'héritage par défaut. C'est la forme la plus restrictive d'héritage : voyez la figure 5.

Dans l'héritage privé, l'interface de la classe de base disparait (l'ensemble des membres publics cessent d'être publics). Autrement dit, on utilise la classe de base pour réaliser l'implémentation de la classe dérivée, mais on s'oblige à écrire une nouvelle interface pour la classe dérivée.

Cela se voit dans l'exemple déjà donné des classes Tableau et Pile (cf. x). Il s'agit d'héritage privé, car les tableaux ne fournissent que l'implémentation des piles, non leur comportement.

Exemple d'emploi d'un tableau :

Tableau t(taille max souhaitée);
...
t[i] = x;
etc.

Emploi d'une pile :

Pile p(taille max souhaitée);
p[i] = x;         // ERREUR : l'opérateur [] est inaccessible
p.empiler(x);       // Oui
...
cout << p[i];       // ERREUR : l'opérateur [] est inaccessible
cout << p.depiler();   // Oui
etc.

À retenir : si D dérive de manière privée de B alors un objet D est une sorte de B, mais les utilisateurs de ces classes n'ont pas à le savoir. Ou encore : ce qu'on peut demander à un B, on ne peut pas forcément le demander à un D.

Héritage protégé. Syntaxe :

class classeDérivée : protected classeDeBase { ... }

Cette forme d'héritage, moins souvent utilisée que les deux autres, est similaire à l'héritage privé (la classe de base fournit l'implémentation de la classe dérivée, non son interface), mais on considère ici que les détails de l'implémentation, c.-à-d. les membres publics et protégés de la classe de base, doivent rester accessibles aux concepteurs d'éventuelles classes dérivées de la classe dérivée.

Héritage public. Syntaxe :

class classeDérivée : public classeDeBase { ... }

Dans l'héritage public (voyez la figure 7), l'interface est conservée : tous les éléments du comportement public de la classe de base font partie du comportement de la classe dérivée. C'est la forme d'héritage la plus fréquemment utilisée, car la plus utile et la plus facile à comprendre : dire que D dérive publiquement de B c'est dire que, vu de l'extérieur, tout D est une sorte de B, ou encore que tout ce qu'on peut demander à un B on peut aussi le demander à un D.

La plupart des exemples d'héritage que nous examinerons seront des cas de dérivation publique.

1. Sauf pour les objets qui sont les valeurs de variables globales, le constructeur d'un objet est appelé immédiatement après l'obtention de l'espace pour l'objet. On peut considérer que l'espace pour les variables globales existe dès que le programme est chargé. Les constructeurs de ces variables sont appelés, dans l'ordre des déclarations de ces variables, juste avant l'activation de la fonction principale du programme (en principe main).
2. L'activation d'un constructeur commence par les appels des constructeurs de chacune de ses classes de base directes, dans l'ordre de déclaration de ces classes de base directes.
3. Sont appelés ensuite les constructeurs de chacun des objets membres, dans l'ordre de déclaration de ces objets membres.
4. Enfin, les instructions qui composent le corps du constructeur sont exécutées.

Sauf indication contraire, les constructeurs dont il est question aux points 2 et 3 sont les constructeurs sans argument des classes de base et des classes des données membres. Si des arguments doivent être précisés (par exemple parce que certaines de ces classes n'ont pas de constructeur sans argument) cela se fait selon la syntaxe :

classe(parametres)
    :   nomDeMembreOuDeClasseDeBase(paramètres),
      ...
      nomDeMembreOuDeClasseDeBase(paramètres) {
  corps du constructeur
  }

Grosso modo, le principe général est celui-ci : les objets « contemporains » (attachés à un même contexte, crées par une même déclaration, etc.) sont détruits dans l'ordre inverse de leur création.

Par conséquent

1. L'exécution du destructeur d'un objet commence par l'exécution des instructions qui en composent le corps.
2. Elle continue par les appels des destructeurs des classes des objets membres, dans l'ordre inverse de leurs déclarations.
3. Sont appelés ensuite les destructeurs des classes de base directes, dans l'ordre inverse des déclarations de ces classes de base.
4. Enfin, l'espace occupé par l'objet est libéré.

À quel moment les objets sont-ils détruits ? Les objets qui sont les valeurs de variables globales sont détruits immédiatement après la terminaison de la fonction principale (en principe main), dans l'ordre inverse de la déclaration des variables globales.

Les objets qui ont été alloués dynamiquement ne sont détruits que lors d'un appel de delete les concernant.

Les objets qui sont des valeurs de variables automatiques (locales) sont détruits lorsque le contrôle quitte le bloc auquel ces variables sont rattachées ou, au plus tard, lorsque la fonction contenant leur définition se termine.

Objets temporaires. Les objets temporaires ont les vies les plus courtes possible. En particulier, les objets temporaires créés lors de l'évaluation d'une expression sont détruits avant l'exécution de l'instruction suivant celle qui contient l'expression.

Les objets temporaires créés pour initialiser une référence persistent jusqu'à la destruction de cette dernière.

Exemple :

{
Point &r = Point(1, 2); // l'objet Point temporaire créé ici vit autant que r,
            // c'est-à-dire au moins jusqu'à la fin du bloc
...
}

{
Point *p = & Point(3, 4);       // ERREUR
Point *q = new Point(5, 6);     // Oui
 
ici, le pointeur p est invalide : le point de coordonnées (3,4) a déjà été détruit
 
delete q;               // Oui
delete p;               // ERREUR (pour plusieurs raisons)
}

Si la classe D dérive publiquement de la classe B alors les membres de B sont membres de D. Autrement dit, les membres publics de B peuvent être atteints à travers un objet D. Ou encore : tous les services offerts par un B sont offerts par un D.

Par conséquent, là où un B est prévu, on doit pouvoir mettre un D. C'est la raison pour laquelle la conversion (explicite ou implicite) d'un objet de type D vers le type B, une classe de base accessible de D, est définie, et a le statut de conversion standard. Exemple :

class Point {             // point « géométrique »
  int x, y;
public:
  Point(int, int);
    ...
};
 
class Pixel : public Point {     // pixel = point coloré
  char *couleur;
public:
  Pixel(int, int, char *);
  ...
};

Utilisation :

Pixel px(1, 2, "rouge");
Point pt = px;             // un pixel a été mis là où un point était
                  // attendu : il y a conversion implicite

De manière interne, la conversion d'un D vers un B est traitée comme l'appel d'une fonction membre de D qui serait publique, protégée ou privée selon le mode (ici : public) dont D dérive de B.

Ainsi, la conversion d'une classe dérivée vers une classe de base privée ou protégée existe, mais n'est pas utilisable ailleurs que depuis l'intérieur de la classe dérivée. Bien entendu, le cas le plus intéressant est celui de la dérivation publique. Sauf mention contraire, dans la suite de cette section nous supposerons être dans ce cas. Selon qu'elle s'applique à des objets ou à des pointeurs (ou des références) sur des objets, la conversion d'un objet de la classe dérivée vers la classe de base recouvre deux réalités très différentes :

1. Convertir un objet D vers le type B c'est lui enlever tous les membres qui ne font pas partie de B (les membres spécifiques et ceux hérités d'autres classes). Dans cette conversion il y a perte effective d'information : voyez la figure 8.

2. Au contraire, convertir un D* en un B* (c'est-à-dire un pointeur sur D en un pointeur sur B) ne fait perdre aucune information. Pointé à travers une expression de type B*, l'objet n'offre que les services de la classe B, mais il ne cesse pas d'être un D avec tous ses membres : voyez la figure 9.

Par exemple, supposons posséder deux fonctions de prototypes :

void fon1(Point pt);
void fon2(Point *pt);

et supposons qu'elles sont appelées de la manière suivante :

Pixel pix = Pixel(2, 3, "rouge")
...
fon1(pix);
fon2(&pix);

Le statut de l'objet pix en tant que paramètre de ces deux fonctions est tout à fait différent. L'objet passé à fon1 comme argument est une version tronquée de pix, alors que le pointeur passé à fon2 est l'adresse de l'objet pix tout entier :

void fon1(Point pt) {

La valeur de pt est un Point ; il n'a pas de couleur. Il y avait peut-être à l'origine un Pixel, mais, ici, aucune conversion (autre que définie par l'utilisateur) ne peut faire un Pixel à partir de pt.

}

void fon2(Point *pt) {

Il n'est rien arrivé à l'objet dont l'adresse a servi à initialiser pt lors de l'appel de cette fonction. Si on peut garantir que cet objet est un Pixel, l'expression suivante (placée sous la responsabilité du programmeur) a un sens :

((Pixel *) pt)->couleur … }

Pour ce qui nous occupe ici, les références (pointeurs gérés de manière interne par le compilateur) doivent être considérées comme des pointeurs. Nous pouvons donc ajouter un troisième cas :

void fon3(Point &rf) {

Il n'est rien arrivé à l'objet qui a servi à initialiser rf lors de l'appel de cette fonction. Si on peut garantir que cet objet est un Pixel, l'expression suivante (placée sous la responsabilité du programmeur) a un sens :

((Pixel &) rf).couleur …
}

Considérons la situation suivante :

class B {
  ...
};
class D : public B {
  ...
};
 
D unD;
...
B unB = unD;
B *ptrB = &unD;
B &refB = unD;

Les trois affectations ci-dessus sont légitimes ; elles font jouer la conversion standard d'une classe vers une classe de base. Le type de unB ne soulève aucune question (c'est un B), mais les choses sont moins claires pour les types de ptrB et refB. Ainsi ptrB, par exemple, pointe-t-il un B ou un D ?

• on dit que le type statique de *ptrB (ce que ptB pointe) et de refB est B, car c'est ainsi que ptB et refB ont été déclarées ;
• on dit que le type dynamique de *ptrB et de refB est D, car tel est le type des valeurs effectives de ces variables.

Le type statique d'une expression découle de l'analyse du texte du programme ; il est connu à la compilation. Le type dynamique, au contraire, est déterminé par la valeur courante de l'expression, il peut changer durant l'exécution du programme.

La notion de type dynamique va nous amener assez loin. Pour commencer, remarquons ceci : gr^ace aux conversions implicites de pointeurs et références vers des pointeurs et références sur des classes de base, tout objet peut être momentanément tenu pour plus général qu'il n'est. Cela permet les traitements génériques, comme dans l'exemple suivant, qui présente un ensemble de classes conçues pour gérer le stock d'un supermarché :

struct Article {
  char *denom;       // denomination
  int quant;         // quantité disponible
  double prix;       // prix HT
  Article(char *d, int q, double p)
    : denom(d), quant(q), prix(p) { }
    ...
};
 
struct Perissable : public Article {
  Date limite;
  Perissable(char *d, int q, double p, Date l)
    : Article(d, q, p), limite(l) { }
  ...
};
 
struct Habillement : public Article {
  int taille;
  Habillement(char *d, int q, double p, int t)
    : Article(d, q, p), taille(t) { }
  ...
};
 
struct Informatique : public Article {
  char garantie;
  Informatique (char *d, int q, double p, char g)
    : Article(d, q, p), garantie(g) { }
  ...
};

Introduisons quelques structures de données (des tableaux de pointeurs) pour mémoriser les diverses classes d'articles présents dans le stock :

Perissable     *aliment[maxAliment];
Habillement   *vetemts[maxVetemts];
Informatique   *info[maxInfo];
etc.

Définissons également une structure pour mémoriser tous les articles du stock :

Article *stock[maxStock];

Initialisons tout cela (notez que chaque adresse fournie par un appel de new est d'abord copiée dans un tableau spécifique et ensuite généralisée et copiée dans le tableau générique) :

nStock = nAliment = nVetemts = nInfo = 0;
stock[nStock++] = aliment[nAliment++] =
    new Perissable("Foie gras Shell 1Kg", 1000, 450.0, Date(15,1,2000));
stock[nStock++] = vetemts[nVetemts] =
    new Habillement("Tenue gendarme fluo rose", 250, 200.0, 52);
stock[nStock++] = info[nInfo++] =
    new Informatique("Pentium III 800 Mhz Diesel HDI", 500, 1000.0, 'C');
etc.

En tant qu'éléments du tableau stock, les objets des classes Perissable, Habillement, etc., sont tenus pour plus généraux qu'ils ne sont, ce qui est très commode pour faire sur chacun une opération générique. Par exemple, le calcul de la valeur totale du stock n'a pas besoin des spécificités de chaque article :

double valeurStock = 0;
for (int i = 0; i < nStock; i++)
  valeurStock += stock[i]->quant * stock[i]->prix;

Dans cet exemple nous avons utilisé la généralisation des pointeurs pour accéder à des membres dont les objets héritent sans les modifier : les notions de quantité disponible et de prix unitaire sont les mêmes pour toutes les sortes d'articles du stock.

La question devient beaucoup plus intéressante lorsqu'on accède à des membres de la classe de base qui sont redéfinis dans les classes dérivées. Voici un autre exemple, classique : la classe Figure est destinée à représenter les éléments communs à tout un ensemble de figures géométriques, telles que des triangles, des ellipses, des rectangles, etc. :

class Figure {
...
};
class Triangle : public Figure {
  ...
};
class Ellipse : public Figure {
  ...
};
Figure *image[maxFigure];
int n = 0;
image[n++] = new Triangle(...);
image[n++] = new Figure(...);
image[n++] = new Ellipse(...);
...
for (int i = 0; i < n; i++)
  image[i]->seDessiner();

Si on suppose que la fonction seDessiner (qui doit nécessairement être déclarée dans la classe Figure, sinon la ligne ci-dessus serait trouvée incorrecte à la compilation) est redéfinie dans les classes Triangle, Ellipse, etc., il est intéressant de se demander quelle est la fonction qui sera effectivement appelée par l'expression image[i]->seDessiner() écrite ci-dessus.

Par défaut, la détermination du membre accédé à travers une expression comme la précédente se fait durant la compilation, c'est-à-dire d'après le type statique du pointeur ou de la référence. Ainsi, dans l'expression

image[i]->seDessiner();

c'est la fonction seDessiner de la classe Figure (probablement une fonction bouche-trou) qui est appelée. Cette réalité décevante obéit à des considérations d'efficacité et de compatibilité avec le langage C; elle semble limiter considérablement l'intérêt de la généralisation des pointeurs…

…heureusement, la section suivante présente un comportement beaucoup plus intéressant !

¹⁵Nous déclarons ici des structures (une structure est une classe dont les membres sont par défaut publiques) pour ne pas nous encombrer avec des problèmes de droits d'accès.

Syntaxe

dynamic_cast<type>(expression)

Il s'agit d'effectuer la conversion d'une expression d'un type pointeur vers un autre type pointeur, les types pointés étant deux classes polymorphes dont l'une, B, est une classe de base accessible de l'autre, D.

S'il s'agit de généralisation (conversion dans le sens D* ! B*), cet opérateur ne fait rien de plus que la conversion standard.

Le cas intéressant est B* ! D*, conversion qui n'a de sens que si l'objet pointé par l'expression de type B* est en réalité un objet de la classe D ou d'une classe dérivée de D.

L'opérateur dynamic cast fait ce travail de manière sure et portable, et rend l'adresse de l'objet lorsque c'est possible, 0 dans le cas contraire :

class Animal {
    ...
    virtual void uneFonction() { // il faut au moins une fonction virtuelle
    ... // (car il faut des classes polymorphes)
    }
};
 
class Mammifere : public Animal {
    ...
};
 
class Chien : public Mammifere {
    ...
};
 
class Caniche : public Chien {
    ...
};
 
class Chat : public Mammifere {
    ...
};
 
class Reverbere {
    ...
};
 
Chien medor;
Animal *ptr = &medor;
...
Mammifere *p0 = ptr;
      // ERREUR (à la compilation) : un Animal n'est pas forcément un Mammifère
Mammifere *p1 = dynamic_cast<Mammifere *>(ptr);
      // OK : p1 reçoit une bonne adresse, car Médor est un mammifère
Caniche *p2 = dynamic_cast<Caniche *>(ptr);
      // OK, mais p2 reçoit 0, car Médor n'est pas un caniche
Chat *p3 = dynamic_cast<Chat *>(ptr);
      // OK, mais p3 reçoit 0, car Médor n'est pas un chat non plus
Reverbere *p4 = dynamic_cast<Reverbere *>(ptr);
      // OK, mais p4 reçoit 0, car Médor n'est pas un réverbère

L'opérateur dynamic_cast s'applique également aux références. L'explication est la même, sauf qu'en cas d'impossibilité d'effectuer la conversion, cet opérateur lance l'exception bad cast :

Animal &ref = medor;
Mammifere &r1 = dynamic_cast<Mammifere &>(ref);   // Oui
Caniche &r2 = dynamic_cast<Caniche &>(ref);     // exception bad cast lancée ;
                          // non attrapée, elle est fatale

Syntaxes :

typeid(type)
ou
typeid(expression)

Le résultat est une valeur de type const type_info&, où type_info est une classe de la bibliothèque standard comportant au moins les membres suivants :

class type_info {
public:
  const char *name() const;
  int operator==(const type_info&) const;
  int operator!=(const type_info&) const;
  int before(const type_info&) const;
    ...
};

On a donc la possibilité de comparer les types dynamiques et d'en obtenir l'écriture des noms. Exemple :

Animal *ptr = new Caniche;
cout << typeid(ptr).name() << '\n';
cout << typeid(*ptr).name() << '\n';
cout << "L'animal pointé par ptr "
   << (typeid(*ptr) == typeid(Chien) ? "est" : "n'est pas")
   << " un chien\n";
cout << "L'animal pointé par ptr est un "
   << typeid(*ptr).name() << "\n";

affichage obtenu :

Animal *
Chien
L'animal pointé par ptr n'est pas un chien
L'animal pointé par ptr est un Caniche

Les fonctions membres d'un modèle de classe sont des modèles de fonctions avec les mêmes paramètres que le modèle de la classe. Cela est implicite pour les déclarations et définitions écrites à l'intérieur du modèle de classe, mais doit être explicité pour les définitions écrites à l'extérieur.

Par exemple, voici notre modèle de classe Table avec des fonctions membres séparées :

template<class TElement> class Table {
  TElement *tab;
  int nbr;
public:
  explicit Table(int);
  ~Table();
  TElement &operator[](int);
  TElement operator[](int) const;
};
 
template<class TElement>
  Table<TElement>::Table(int n) {
    tab = new TElement[nbr = n];
  }
template<class TElement>
  Table<TElement>::~Table() {
    delete [] tab;
  }
template<class TElement>
  TElement &Table<TElement>::operator[](int i) {
    contrôle de la validité de i
    return tab[i];
  }
template<class TElement>
  TElement Table<TElement>::operator[](int i) const {
    contrôle de la validité de i
    return tab[i];
}

Les paramètres des modèles de classes peuvent avoir des valeurs par défaut. Voici, par exemple, une autre version de nos tables, dans laquelle l'allocation du tableau n'est pas dynamique ; par défaut, ce sont des tables de 10 entiers :

template<class TElement = int, int N = 10>
  class TableFixe {
    TElement tab[N];
public:
  TElement & operator[](int i) {
    IndiceValide(i, N);
    return tab[i];
  }
  TElement operator[](int i) const {
    IndiceValide(i, N);
    return tab[i];
  }
};
 
TableFixe<float, 10> t1;     // Oui, table de 10 float
TableFixe<float> t2;       // Oui, table de 100 float
TableFixe<> t3;         // Oui, table de 100 int
TableFixe t4;           // ERREUR

Comme une classe, un modèle peut être « annoncé », c'est-à-dire, déclaré et non défini. Il pourra alors être utilisé dans toute situation ne nécessitant pas de connaitre sa taille ou ses détails internes :

template<class TElement> class Table;
Table<float> table1;       // ERREUR
Table<float> *ptr;         // Oui
ptr = new Table<float>;     // ERREUR
extern Table<float> table2;   // Oui