Überladen den Operator == in C++

1. Operatorüberladung in C++
2. Überladen Sie den Operator == in C++
3. Überladen Sie den Operator == in der Klassenhierarchie

Dieser Artikel behandelt die Grundlagen des Überladens von Operatoren und bietet eine einfache Implementierung des Operators == in einer Klasse.

Operatorüberladung in C++

Das Überladen von Operatoren bezieht sich auf das Ändern, wie ein Operator handeln muss, wenn er zusammen mit den benutzerdefinierten Datentypen wie Klassenobjekten und Strukturen verwendet wird. Diese sind wie Mitgliedsfunktionen in einer Klasse, die aufgerufen wird, diesen Operator zu verwenden.

Wenn wir zum Beispiel eine Klasse Student haben und überprüfen möchten, welche Schülernoten besser sind als die anderen, dann können wir den Operator > überladen, der das Datenelement marks der beiden Objekte vergleichen kann und das Ergebnis zurückgeben.

Die Syntax für das Überladen von Operatoren lautet wie folgt:

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

Beachten Sie, dass operator ein Schlüsselwort ist, das zum Überladen von Operatoren verwendet wird, und danach geben wir das Symbol des Operators an, der überladen werden muss. Denken Sie daran, dass wir Operatoren für grundlegende Datentypen wie int, char, float usw. nicht überladen können.

Fast alle Operatoren können überladen werden, mit Ausnahme einiger weniger, die nicht überladen werden dürfen. Zu diesen Operatoren gehören:

• der sizeof-Operator
• der typeid-Operator
• die Bereichsauflösung (::)
• die Klassenmember-Zugriffsoperatoren (.(Punkt), .* (Zeiger auf Member-Operator)
• der Bedingungsoperator (?:)

Überladen Sie den Operator == in C++

== ist auch der gleich-Operator, der unter die Klassifizierung der Vergleichsoperatoren fällt und ein boolesches Ergebnis von true oder false zurückgibt. Es bestimmt, ob die beiden Operanden auf der linken und rechten Seite des Operators gleich sind.

Für benutzerdefinierte Datentypen wie class kann dieser Operator überladen werden, um zwei Objekte einer Klasse zu vergleichen und zu prüfen, ob alle Datenelemente der beiden Objekte gleich sind oder nicht.

Stellen Sie sich eine Klasse Employee mit den folgenden Datenelementen vor:

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

In dieser Klasse können wir den Operator == überladen, um zu prüfen, ob die Objekte der beiden Mitarbeiter gleich sind oder nicht. Diese Funktion kann implementiert werden als:

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

Jetzt können wir sie alle zusammenfügen, um eine komplette Klasse zu haben.

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

Ausgabe:

Equal

Überladen Sie den Operator == in der Klassenhierarchie

Wenn Sie über mehrere Klassen verfügen, sodass einige Klassen übergeordnete und einige untergeordnete Klassen sind, müssen Sie die Operatorfunktion in allen Unter- und Oberklassen implementieren. Wenn es beispielsweise eine Klasse A gibt und Sie den Operator == implementieren, ist dieser überladene Operator für alle seine Unterklassen verfügbar.

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

Jetzt haben wir eine weitere Klasse, B, eine Unterklasse von A.

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

Wenn wir den Operator == nicht in dieser Klasse implementieren, ruft sie die Operatorfunktion der Basisklasse auf, aber das Problem besteht darin, dass die Basisklasse nur ihre eigenen Datenelemente vergleicht, nicht aber die der B Klasse. Daher müssen wir den Operator auch in der untergeordneten Klasse implementieren.

Nach dieser Implementierung wird die Implementierung der Basisklasse nicht aufgerufen, bis wir sie explizit aufrufen. Daher rufen wir diese Funktion explizit auf, um die Datenmember der Basisklasse zu vergleichen.

Dies wird im folgenden Code-Snippet demonstriert:

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

Die Treiberfunktion wird sein:

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

Ausgabe:

Equal