Surcharger l'opérateur == en C++

1. Surcharge d’opérateur en C++
2. Surcharger l’opérateur == en C++
3. Surcharger l’opérateur == dans la hiérarchie des classes

Cet article aborde les bases de la surcharge d’opérateurs et fournit une implémentation simple de l’opérateur == dans une classe.

Surcharge d’opérateur en C++

La surcharge d’opérateur fait référence à la modification de la manière dont un opérateur doit agir lorsqu’il est utilisé avec les types de données définis par l’utilisateur, tels que les objets de classe et les structures. Ce sont comme des fonctions membres dans une classe appelées à utiliser cet opérateur.

Par exemple, si nous avons une classe Student et que nous voulons vérifier quelles notes des étudiants sont supérieures aux autres, alors nous pouvons surcharger l’opérateur > qui peut comparer les données membres marks des deux objets et retourner le résultat.

La syntaxe de surcharge d’opérateur est la suivante :

class className {
 public:
  returnType operator operatorSymbol([list of arguments]) {
    // definition
  }
};

Notez que operator est un mot-clé utilisé pour la surcharge d’opérateur, et après cela, nous spécifions le symbole de l’opérateur qui doit être surchargé. N’oubliez pas que nous ne pouvons pas surcharger les opérateurs pour les types de données fondamentaux comme int, char, float, etc.

Presque tous les opérateurs peuvent être surchargés à l’exception de quelques-uns qui ne sont pas autorisés à être surchargés. Ces opérateurs comprennent :

• l’opérateur sizeof
• l’opérateur typeid
• la résolution de portée (::)
• les opérateurs d’accès membres de la classe (.(point), .* (pointeur vers l’opérateur membre)
• l’Opérateur conditionnel (?:)

Surcharger l’opérateur == en C++

== est également l’opérateur égal à qui relève de la classification des opérateurs de comparaison et renvoie un résultat booléen de true ou false. Il détermine si les deux opérandes des côtés gauche et droit de l’opérateur sont égaux l’un à l’autre.

Pour les types de données définis par l’utilisateur comme la classe, cet opérateur peut être surchargé pour comparer deux objets d’une classe afin de vérifier si toutes les données membres des deux objets sont égales ou non.

Considérons une classe Employee ayant les membres de données suivants :

class Employee {
 private:
  string name;
  int salary;
};

Dans cette classe, on peut surcharger l’opérateur == pour vérifier si les objets des deux employés sont égaux ou non. Cette fonction peut être implémentée comme :

bool operator==(const Employee &emp) {
  if (name == emp.name && salary == emp.salary) return true;
  return false;
}

Maintenant, nous pouvons les assembler pour avoir une classe complète.

#include <iostream>
#include <string>
using namespace std;

class Employee {
 private:
  string name;
  int salary;

 public:
  Employee(string n, int s) {
    name = n;
    salary = s;
  }
  bool operator==(const Employee &emp) {
    if (name == emp.name && salary == emp.salary) return true;
    return false;
  }
};
int main() {
  Employee e1("David", 1000);
  Employee e2("David", 1000);
  if (e1 == e2)
    cout << "Equal" << endl;
  else
    cout << "Not Equal" << endl;
}

Production:

Equal

Surcharger l’opérateur == dans la hiérarchie des classes

Si vous avez plusieurs classes, telles que certaines classes sont des parents et d’autres des classes enfants, vous devez implémenter la fonction d’opérateur dans toutes les sous-classes et superclasses. Par exemple, s’il existe une classe A et que vous implémentez l’opérateur ==, cet opérateur surchargé sera disponible pour toutes ses sous-classes.

class A {
 public:
  int foo;
  bool operator==(const A &a) { return foo == a.foo; }
};

Maintenant, nous avons une autre classe, B, une sous-classe de A.

class B : public A {
 public:
  int bar;
};

Si nous n’implémentons pas l’opérateur == dans cette classe, elle appellera la fonction opérateur de la classe de base, mais le problème est que la classe de base ne compare que les membres de données qui lui sont propres, mais pas ceux du classe B. Par conséquent, nous devons également implémenter l’opérateur dans la classe enfant.

Après cette implémentation, l’implémentation de la classe de base ne sera pas appelée jusqu’à ce que nous l’appelions explicitement. Par conséquent, nous appelons cette fonction explicitement pour comparer les membres de données de la classe de base.

Ceci est démontré dans l’extrait de code ci-dessous :

class B : public A {
 public:
  int bar;
  bool operator==(const B &b) {
    if (!A::operator==(static_cast<const A &>(b))) {
      return false;
    }
    return bar == b.bar;
  }
};

La fonction de conducteur sera :

int main() {
  B b;
  b.bar = 2;
  b.foo = 1;
  B b2;
  b2.bar = 2;
  b2.foo = 1;
  if (b == b2) {
    cout << "Equal" << endl;
  }
}

Production:

Equal