La surcharge d’opérateur en C++ 1

Parfois, il nous est utile de pouvoir comparer deux objets d’une même classe entre eux, le problème c’est que les objets (instances d’une classe) ne peuvent êtres comparés avec un simple « if », il nous faudra donc préciser pour la classe en question quels opérateurs on voudra utiliser pour notre traitement.

Prenons un exemple simple :

Je code la classe Heure de la façon suivante :

#ifndef HEURE_H
#define HEURE_H
#include <iostream>
using namespace std;

class Heure
{
    public:
        Heure();
        Heure(int m_heure, int m_minute);
        virtual ~Heure();
        int getHeure();
        int getMinute();

    private:
        int heure, minute;

};

#endif // HEURE_H

Je veux savoir plusieurs choses, sans avoir à comparer mes valeurs que renvoient mes méthodes getHeure() et getMinute() à chaque fois que cela est nécessaire. Donc, je vais implémenter une utilisation personnalisée de certains opérateurs. Admettons que je veuille tester si deux heures sont égales, et que je veuille aussi permettre l’affichage d’une heure de cette façon :

cout << monHeure; // mon heure étant un objet "Heure"

Bien, pour cela je vais rajouter ces lignes dans le prototype de classe (dans « public ») :

bool operator==(const Heure &monHeure);
friend ostream &operator<<(ostream & os, const Heure &monHeure);

Nous avons donc respectivement, le prototype de la surcharge de l’opérateur « == » et « <<« .
Voyons maintenant l’implémentation du code pour chacune de ces méthodes.

bool Heure::operator==(const Heure &monHeure)
{
    if((heure == monHeure.heure )&&( minute == monHeure.minute ))
    {
        return true;
    }
    else
    return false;
}

ostream &operator<<(ostream &os, const Heure &monHeure)
{
    return os << monHeure.heure << "h" <<monHeure.minute << endl;
}

Pour la méthode operator==(), je me contente de comparer mon objet actuel à celui passé en paramètre, heure et minutes font référence à l’objet actuel qui exécute la méthode, et monHeure.heure et monHeure.minute font eux référence à l’objet « Heure » passé en paramètre de la méthode.

Voyez cela comme si je comparais tout simplement deux attributs de deux objets de même type. Je retourne false si les heures ne sont pas égales et true si elles le sont.

Je pourrais maintenant l’utiliser ! Voyons un simple exemple d’utilisation :

if(heureDejeuner==heureRdvMedecin)
{
      cout << "Je dois manger plus tôt !" << endl;
} else {
      cout << "J'ai le temps de manger." << endl;
}

Bon, bien entendu, si les heures varient d’une minute, elles ne seront pas égales mais on aura quand même pas le temps de manger 🙂 Ceci est seulement à titre d’exemple, mais libre à vous d’adapter le code contenu dans la méthode de surcharge de « == », pour dire que si les heures ont moins d’une heure d’écart, on renvoie true, de façon à laisser le temps de manger. Vous pouvez également passer un deuxième paramètre qui est le temps associé de durée de la tâche/action qui commence à l’heure H.

Et pour finir voici le code, très simple, de la surcharge de « << » :

ostream &operator<<(ostream &os, const Heure &monHeure)
{
    return os << monHeure.heure << "h" <<monHeure.minute << endl;
}

Qui retourne le flux « os » d’affichage, contenant l’heure, et la minute, de l’objet que l’on veut afficher. L’utilisation, est on ne peut plus simple :

Heure heureReveil(6,50);   // 7h00
cout << heureReveil;   // ici on affichera "6h50"

En espérant que cela est clair, n’hésitez pas si vous avez des questions 😉