La surcharge d'opérateurs

Qu'est-ce que c'est ?

Le principe est très simple. Supposons que vous ayez créé une classe pour stocker une durée (ex. : 4h23m), et que vous avez 2 objets de type Duree. Vous voulez les additionner entre eux pour connaître la durée totale.

En temps normal, il faudrait créer une fonction "additionner" :

Code : C++

La fonction additionner ferait ici la somme de duree1 et duree2 et stockerait ça dans resultat.
Ca fonctionne, mais ce n'est pas franchement lisible. Ce que je vous propose dans ce chapitre, c'est d'être capable d'écrire ça :

Code : C++

En clair, on fait ici comme si nos objets étaient de simples "nombres". Mais comme un objet c'est plus complexe qu'un nombre (vous avez eu l'occasion de vous en rendre compte ), il va falloir expliquer à l'ordinateur comment effectuer l'opération.

La classe Duree pour nos exemples

Toutes les classes ne sont pas forcément adaptées à la surcharge d'opérateurs. Ainsi, ajouter des objets de type Personnage entre eux serait pour le moins un peu louche
Nous allons donc changer d'exemple, ça sera l'occasion de vous aérer un peu l'esprit sinon vous allez finir par croire que le C++ ne sert qu'à créer des RPG

Cette classe Duree sera capable de stocker des heures, des minutes et des secondes. Rassurez-vous, c'est une classe relativement facile à écrire (plus facile que Personnage en tout cas !), ça ne devrait vous poser aucun problème si vous avez compris les chapitres précédents.

Duree.h

Code : C++

Chaque objet de type Duree stockera un certain nombre d'heures, minutes et secondes.

Vous noterez que j'ai utilisé des valeurs par défaut au cas où l'utilisateur aurait la flemme de les préciser
On pourra donc créer un objet de plusieurs façons différentes :

Code : C++

Duree.cpp

L'implémentation de notre constructeur est expédiée en 30 secondes montre en main

Code : C++

Et dans main.cpp ?

Pour l'instant notre main.cpp ne va déclarer que 2 objets de type Duree, que j'initialise un peu au pif :

Code : C++

Voilà, nous sommes prêts à affronter les surcharges d'opérateurs maintenant !

Nous allons commencer par voir les opérateurs mathématiques les plus classiques, à savoir l'addition, la soustraction, la multiplication, la division et le modulo.
Une fois que vous aurez appris à vous servir de l'un d'entre eux, vous verrez que vous saurez vous servir de tous les autres


Pour être capable d'utiliser le symbole "+" entre 2 objets, vous devez créer une méthode ayant précisément pour nom operator+ qui a pour prototype :

Code : C++

La méthode reçoit donc une référence sur l'objet (constant, donc on ne peut pas le modifier) à additionner.
Dans notre classe Duree, on doit donc rajouter cette méthode (ici dans le .h) :

Code : C++

Mode d'utilisation

Dès le moment où vous avez créé cette méthode operator+, vous pouvez additionner 2 objets de type Duree entre eux :

Code : C++

Ce n'est pas de la magie. En fait le compilateur "traduit" ça par :

Code : C++

... ce qui est beaucoup plus classique et compréhensible pour lui
Il appelle donc la méthode operator+ de l'objet duree1, et envoie duree2 en paramètre à la méthode. La méthode, elle, va retourner un résultat de type Duree.

Implémentation

L'implémentation n'est pas vraiment compliquée, mais il va quand même falloir réfléchir un peu. En effet, ajouter des secondes, minutes et heures ça va, mais il faut faire attention à la retenue si ça dépasse 60.
Je vous recommande d'essayer d'écrire la méthode vous-même, c'est un excellent exercice algorithmique, ça entretient le cerveau, ça vous rend meilleur programmeur (je vous ai convaincus là ? )

Voici ce que donne mon implémentation pour ceux qui ont besoin de la solution :

Code : C++

Ce n'est pas un algorithme ultracomplexe, mais comme je vous avais dit il faut réfléchir un tout petit peu pour pouvoir l'écrire quand même

On commence par créer et initialiser 3 variables locales (heures, minutes et secondes) qui correspondent au résultat. Ce résultat, on le mettra dans un objet de type Duree que l'on renverra à la fin.

On a initialisé ces 3 variables avec la valeur de l'objet sur lequel on travaille (duree1 si on se fie à l'exemple donné un peu plus haut).
On va y ajouter les heures, minutes et secondes de l'objet reçu en paramètre, à savoir duree2. Comme on l'avait vu dans le chapitre précédent, on a exceptionnellement le droit d'accéder directement aux attributs de cet objet car on se trouve dans une méthode de la même classe. C'est un peu tordu mais ça nous aide bien (sinon il aurait fallu créer des méthodes "accesseur" comme getHeures()).

Rajouter les secondes, c'est facile. Mais ensuite on doit rajouter un reste si on a dépassé 60 secondes (donc rajouter des minutes). Je ne vous explique pas comment ça fonctionne dans le détail, je vous laisse vous remuer les méninges un peu, ce n'est vraiment pas bien difficile (c'est du niveau des tous premiers chapitres du cours ). Vous noterez que c'est un cas où l'opérateur modulo (%), à savoir le reste de la division, est très utile.

Bref, on fait de même avec les minutes, et quant aux heures c'est encore plus facile vu qu'il n'y a pas de reste (on peut dépasser les 24 heures donc pas de problème).

Quelques tests

Pour mes tests, j'ai dû rajouter une méthode afficher() à la classe Duree (elle fait un cout de la durée tout bêtement).

Voilà mon bôôô main :

Code : C++

Et le tant attendu résultat à l'écran :

Code : Console

Cool, ça marche
Bon mais ça c'était trop facile, il n'y avait pas de reste dans mon calcul. Corsons un peu les choses avec d'autres valeurs :

Code : Console

Yeahhh ! Ca marche ! (et du premier coup pour moi nananère )
J'ai bien entendu testé d'autres valeurs pour être bien sûr que ça fonctionnait, mais de toute évidence ça marche très bien et mon algo est donc bon


Bon, on en viendrait presque à oublier l'essentiel dans tout ça. Tout ce qu'on a fait là, c'était pour pouvoir écrire cette ligne :

Code : C++

La surcharge de l'opérateur + nous a permis de rendre notre code clair, simple et lisible, alors qu'on aurait dû utiliser une méthode en temps normal.

Télécharger le projet

Pour ceux d'entre vous qui n'auraient pas bien suivi la procédure, ou qui sont tout simplement fainéants ( ), je vous propose de télécharger le projet contenant :

• main.cpp
• Duree.cpp
• Duree.h
• Ainsi que le fichier .cbp de Code::Blocks (si vous utilisez cet IDE comme moi)

Bonus track #1

Ce qui est vraiment sympa dans tout ça, c'est que tel que notre système est fait, on peut très bien additionner plusieurs durées en même temps sans aucun problème.

Par exemple, je rajoute juste une troisième durée dans mon main et je l'additionne avec les autres :

Code : C++

Code : Console

C'est cool non vous trouvez pas ?
En fait, la ligne-clé :

Code : C++

... revient à écrire :

Code : C++

Le tout s'imbrique dans une logique implacable et vient se placer finalement dans l'objet resultat



Vous voyez ici un exemple un peu plus mathématique (mais pas vraiment compliqué) de l'intérêt de la POO. En C, la même chose était faisable, mais on aurait mélangé les heures, minutes et secondes de chacun. Ici, tout est regroupé et chaque "Duree" est suffisamment intelligente pour être capable de s'additionner avec d'autres durées (et de faire bien d'autres choses encore !).

Bonus track #2

Et pour notre seconde bonus track, sachez qu'on n'est pas obligé d'additionner des Duree avec des Duree, du temps que ça reste logique et compatible.
Par exemple, on pourrait très bien additionner une Duree et un int. On considérerait dans ce cas que le nombre int est un nombre de secondes à ajouter.

Cela nous permettra d'écrire par exemple :

Code : C++

Vive la surcharge des fonctions !

Code : C++

... mais vous croyiez tout de même pas que j'allais vous écrire l'implémentation. Allez hop hop hop au boulot !

Les autres opérateurs arithmétiques

Maintenant que vous avez vu assez en détail le cas d'un opérateur (celui d'addition pour ceux qui ont la mémoire courte ), vous allez voir que pour la plupart des autres opérateurs c'est très facile et qu'il n'y a pas de difficulté supplémentaire. Le tout est de s'en servir correctement pour la classe que l'on manipule.

Ces opérateurs sont du même "type" que l'addition. Vous les connaissez déjà :

• La soustraction (-)
• La multiplication (*)
• La division (/)
• Le modulo (%), c'est-à-dire le reste de la division

Pour surcharger ces opérateurs, rien de plus simple : créez une méthode dont le nom commence par operator suivi de l'opérateur en question. Cela donne donc :

• operator-
• operator*
• operator/
• operator%

Pour notre classe Duree, il peut être intéressant de définir la soustraction (operator-).
Je vous laisse le soin de le faire, en vous basant sur l'addition ça ne devrait pas être trop compliqué

En revanche, les autres opérateurs ne servent a priori à rien : en effet, on ne multiplie pas des durées entre elles, et on les divise encore moins. Comme quoi, tous les opérateurs ne sont pas utiles à toutes les classes : ne définissez donc que ceux qui vous seront vraiment utiles.

Ces opérateurs vont vous permettre de comparer des objets entre eux. Le plus utilisé d'entre eux est probablement l'opérateur d'égalité (==) qui permet de vérifier si 2 objets sont égaux. C'est à vous d'écrire le code de la méthode qui détermine si les objets sont identiques, l'ordinateur ne peut pas le deviner pour vous car il ne connaît pas la "logique" de vos objets

Tous ces opérateurs de comparaison ont un point en commun particulier : ils renvoient un booléen (bool) et non un objet comme c'était le cas des autres opérateurs.

L'opérateur ==

On va écrire l'implémentation de l'opérateur d'égalité pour commencer, vous allez voir que c'est très simple :

Code : C++

On compare à chaque fois un attribut de l'objet dans lequel on se trouve avec un attribut de l'objet auquel on se compare (les heures avec les heures, les minutes avec les minutes...). Si ces 3 valeurs sont identiques alors on peut considérer que les objets sont identiques et renvoyer true (vrai).

Dans le main, on peut faire un simple test de comparaison pour vérifier si on a fait les choses correctement :

Code : C++

Résultat :

Code : Console

L'opérateur <

Je vous préviens on va pas tous les faire sinon on y est encore demain

Si l'opérateur == peut s'appliquer à la plupart des objets, il n'est pas certain que l'on puisse dire de tous nos objets qui est le plus grand. Tous n'ont pas forcément une notion de grandeur, prenez par exemple notre classe Personnage, il serait je pense assez stupide de vouloir vérifier si un Personnage est "inférieur" à un autre ou non (à moins que vous ne compariez les vies... à vous de voir).

En tout cas avec la classe Duree on a de la chance, il est facile et "logique" de vérifier si une Duree est inférieure à une autre.

Voici mon implémentation pour l'opérateur "est strictement inférieur à" (<) :

Code : C++

Avec un peu de réflexion on finit par trouver cet algorithme, il suffit d'activer un peu ses méninges
Vous noterez que la méthode renvoie false si les durées sont identiques : c'est normal, car il s'agit de l'opérateur "strictement inférieur à" (<). En revanche, si ça avait été la méthode de l'opérateur "inférieur ou égal à" (<=), il aurait fallu renvoyer true.

Je vous laisse le soin de tester dans le main si ça fonctionne correctement

Les autres opérateurs de comparaison

On ne va pas les implémenter ici, ça surchargerait inutilement. Par contre, je vous invite à essayer de les implémenter pour notre classe Duree, ça fera un bon exercice d'algorithmie. Il reste notamment :

• operator>
• operator<=
• operator>=
• operator!=

Un des principaux pièges de ce chapitre vient de l'opérateur "=" que l'on peut lui aussi surcharger. C'est l'opérateur d'affectation, qui permet donc de donner une valeur à un objet.

En fait, le "piège" vient du fait que vous risquez de le confondre avec le constructeur de copie. C'est pourquoi je vais insister plus précisément sur cet opérateur pour que vous voyiez bien la différence et ce à quoi il sert.

Rappel : le constructeur de copie

Quand le constructeur de copie est-il appelé ? Vous vous en souvenez ?
Il y a en fait plusieurs cas, les 3 principaux étant :

1/ Lors de l'appel explicite au constructeur de copie

Lorsque vous déclarez un objet et que vous indiquez en paramètre un autre objet, le constructeur de copie est appelé :

Code : C++

2/ Lors d'une affectation au moment de la déclaration

C'est pareil, sauf qu'on utilise le signe "=" ce qui rend le code plus lisible :

Code : C++

3/ Lors d'un appel de fonction qui prend un objet en paramètre

Si la fonction prend un objet (et non pas un pointeur ni une référence) en paramètre, l'objet est "copié" spécialement pour la fonction. Il y a appel du constructeur de copie avant le début de la fonction.

Code : C++

Le rapport avec la surcharge de l'opérateur = ?

Si elle existe, la méthode operator= sera appelée dès qu'on essaie d'affecter une valeur à notre objet.
Par exemple, si à un moment dans le code on affecte à notre objet la valeur d'un autre objet :

Code : C++



Non justement, c'est là qu'est le piège. Dans le cas n°2 vu plus haut, c'est lors de la déclaration de l'objet qu'on fait une affectation. Dans ce cas, c'est le constructeur de copie qui est appelé.
En revanche, dans tout le reste du code, si on affecte une valeur à notre objet, c'est cette fois la méthode operator= qui sera appelée.

Donc en résumé :

• Lors de la déclaration (création) de notre objet, si vous utilisez le signe "=" pour lui affecter immédiatement la valeur d'un autre objet, c'est le constructeur de copie qui est appelé.
  
  Code : C++

  1	Objet copieObjet = monObjet; // Déclaration de l'objet

  
  
  
• Après, à n'importe quel autre moment, si vous décidez d'affecter la valeur d'un autre objet à votre objet, c'est la méthode surchargeant l'opérateur = (operator=) qui sera appelée.
  
  Code : C++

  1	copieObjet = monObjet; // Affectation APRES la déclaration

J'espère avoir été suffisamment clair
Cela signifie donc qu'en général vous devrez écrire le code du constructeur de copie et de l'opérateur "=" en même temps si vous voulez qu'à n'importe quel moment dans votre code on puisse faire une affectation sur votre objet.

Implémentation de la méthode operator= pour la classe Duree

Puisqu'on y est, implémentons la méthode pour la classe Duree et on sera tranquille

Code : C++

Vous noterez que la méthode renvoie l'objet lui-même. En effet, souvenez-vous, this est un pointeur vers l'objet. Si on écrit *this, c'est donc l'objet lui-même que l'on renvoie. Cela permet de traiter le cas où on chaîne les affectations :

Code : C++

Ce n'est pas très courant mais mieux vaut être prévoyant.

A part ça c'est tout bête. Et dans le même temps, si ce n'est pas fait, je vous conseille d'écrire le constructeur de copie pour que le signe "=" fonctionne dans tous les cas. Le code devrait être quasiment le même.

Parmi les nombreuses choses qui ont dû vous choquer quand vous avez commencé le C++, dans la catégorie "oulah c'est bizarre ça mais on verra plus tard", il y a les flux d'entrée-sortie. Derrière ce nom barbare se cachent ces petits symboles >> et <<.
Quand les utilise-t-on ? Allons allons, vous n'allez pas me faire croire que vous avez la mémoire si courte

Code : C++

Figurez-vous justement que << et >> sont des opérateurs. Le code ci-dessus revient donc à écrire :

Code : C++

On a donc fait appel aux méthodes operator<< et operator>> des objets cout et cin !

Définir ses propres flux pour cout

Nous allons ici nous intéresser plus particulièrement à l'opérateur << utilisé avec cout.
Les opérateurs de flux sont définis par défaut pour les types de variables int, double, char*, ainsi que pour les objets comme string. C'est ainsi que l'on peut aussi bien écrire :

Code : C++

... que :

Code : C++

(et c'est là qu'on dit "merci la surcharge des méthodes !" )

Bon, le problème c'est que cout ne connaît pas votre classe flambant neuve Duree, et donc qu'il ne possède pas de méthode surchargée pour les objets de ce type. On ne peut donc pas écrire :

Code : C++

Qu'à cela ne tienne, nous allons écrire cette méthode !



Déjà si vous vous êtes posé la question, bravo, c'est que vous commencez à bien vous repérer. En effet, c'est une méthode de la classe ostream (dont l'objet cout est une instance) que l'on doit définir, et on n'a pas accès au code correspondant.


Par contre, il est possible de créer de simples fonctions (en dehors des objets) pour surcharger des opérateurs. C'est un peu particulier je le reconnais, mais on n'a pas le choix dans le cas présent.

Implémentation d'operator<< en tant que fonction

C'est donc une surcharge d'opérateur un peu particulière que nous allons faire : nous allons écrire une fonction, en dehors de toute classe donc, et non pas une méthode.
Comme c'est un cas assez particulier et que vous n'aurez pas à la reproduire tous les jours, je vous recommande de me suivre pas à pas.

Commencez par écrire cette fonction :


Code : C++

Vous devriez la placer avant le main (ou tout du moins son prototype), sinon le main ne la connaîtra pas.

Le premier paramètre (référence sur un objet de type ostream) qui vous sera automatiquement passé est en fait l'objet cout (que l'on appelle ici out dans la fonction pour éviter les conflits de nom). Le second paramètre est une référence vers l'objet de type Duree que vous tentez d'afficher en utilisant le flux <<.

La fonction doit récupérer les attributs qui l'intéressent dans l'objet et les envoyer à l'objet "out" (qui n'est autre que cout). Ensuite, elle retourne cet objet, ce qui permet de pouvoir faire une chaîne :

Code : C++



Eh oui c'est parfaitement normal, car on est à l'extérieur de la classe, et les attributs m_heures, m_minutes et m_secondes sont privés. On ne peut donc pas les lire de cet endroit du code.

2 solutions :

• Ou bien vous créez des accesseurs comme on l'a vu (ces fameuses méthodes getHeures, getMinutes...), ça marche bien mais c'est un peu ennuyeux à écrire
• Ou bien vous utilisez la technique que je vais vous montrer

On va opter ici pour la seconde solution
Changez la 1ère ligne de la fonction comme ceci :

Code : C++

Et rajoutez une méthode afficher dans la classe Duree.
Prototype à mettre dans Duree.h :

Code : C++

Implémentation de la méthode dans Duree.cpp :

Code : C++

On passe donc le relai à une méthode à l'intérieur de la classe, qui, elle, a le droit d'accéder aux attributs. La méthode prend en paramètre la référence vers l'objet out pour pouvoir lui envoyer les valeurs qui nous intéressent. Ce qu'on n'a pas pu faire dans la fonction operator<<, on le donne à faire à une méthode de la classe Duree.

Ouf ! Maintenant dans le main, que du bonheur !

Bon, c'était un peu gymnastique, mais maintenant c'est que du bonheur
Vous allez pouvoir dans votre main afficher vos objets de type Duree très simplement :

Code : C++

Résultat :

Code : Console

Enfantin
Comme quoi, on prend un peu de temps pour écrire la classe, mais ensuite quand on doit l'utiliser c'est extrêmement simple !


Si vous avez un peu du mal à vous repérer dans le code, ce que je peux comprendre, je mets à votre disposition le projet complet comme tout à l'heure dans ce zip :

1

resultat = tempsLimite.operator-(chrono);