Définir un opérateur

Il existe des fonctions particulières que l'on peut définir sur les objets: des opérateurs, c-à-d des fonctions dont l'un des arguments sera située à leur gauche quand elles sont appelées.

Considérons l'opérateur +. On pourrait construire une fonction somme du type suivant:

Tableau somme(Tableau A, Tableau B);

qui prend deux Tableau comme arguments et en retourne un troisième. L'appel à cette fonction dans le programme se ferait avec la syntaxe habituelle: somme(A, B) .

Une première amélioration apportée par les classes est que l'on peut faire de cette fonction une fonction membre en la déclarant dans la classe sous la forme:

Tableau somme(Tableau B);

et en l'appelant par A.somme(B) .

Mieux encore, il existe certains noms de fonctions membres (+, -, =, ==, +=, etc) pour lesquels le point précédant le nom de la fonction disparaît, de même que les parenthèses nécessaire pour encadrer le second argument. Il s'agit des opérateurs. Ils se déclarent de la façon suivante:

Tableau operator+(Tableau B);

pour s'utiliser ainsi: A + B .

Ainsi dans notre exemple l'opérateur + serait défini ainsi:

class Tableau {

  double* tab;
  int n;

 public: 

  void alloue(int a);
  int consulte_n();
  double consulte_element(int i);
  void modifie_element(int i, double x);

  Tableau operator+(Tableau B){
    Tableau C;
    if (n != B.n) {
      // provoquer une erreur car on ne peut pas sommer deux tableaux de
      //   taille différentes !
    } else {
      C.alloue(n);
      for (int i = 0; i<n; i++)
        C.tab[i] = tab[i] + B.tab[i];      
    }
    return C;
  }

};

et son utilisation, fort pratique, serait:

int taille = 4;

Tableau A;
A.alloue(taille);

Tableau B;
B.alloue(taille);

for (int i = 0; i<taille; i++) {
  A.modifie_element(i, 3.14);
  B.modifie_element(i, 2.78 - i);
}

Tableau C;
C = A + B;

L'addition est ici simple, pratique à appeler, mais la modification d'un élément d'un tableau le semble un peu moins. Pour ce faire, il existe d'autres opérateurs, tels l'opérateur parenthèses () et l'opérateur crochets [] que l'on peut redéfinir. Exemple: on ajoute l'opérateur parenthèses dans la classe par:

double operator()(int i) {
  return tab[i];
}

On peut dès lors consulter simplement un élément du tableau:

Tableau R;
R.alloue(4);
R.modifie_element(0, 3.14);
double z = R(0);

Cependant cela ne permet que de consulter une copie de la valeur de R.tab[i], donc on ne peut pas ainsi modifier un élément du tableau. Pour ce faire il faut retourner l'élément du tableau lui-même, c-à-d une référence sur la variable stockant la valeur de demandée. L'opérateur doit alors être remplacé par:

double& operator()(int i) {
  return tab[i];
}

et dès ce moment-là on peut modifier les éléments du tableau:

Tableau R;
R.alloue(4);
R(0) = 3.14;

Le passage précédent pour construire deux tableaux A et B et les sommer devient:

int taille = 4;

Tableau A;
A.alloue(taille);

Tableau B;
B.alloue(taille);

for (int i = 0; i<taille; i++) {
  A(i) = 3.14;
  B(i) = 2.78 - i;
}

Tableau C;
C = A + B;

ce qui est plus lisible et pratique d'emploi.