Einführung in die Operatorüberladung

Teil des Abschnitts Objektorientierte Programmierung der C++-Journey von Coddy — Lektion 40 von 104.

Operatorüberladung ermöglicht es Ihnen zu definieren, wie Operatoren wie +, -, oder == sich verhalten, wenn sie mit Ihren benutzerdefinierten Klassen verwendet werden. Anstatt Methoden wie a.add(b) aufzurufen, können Sie das intuitivere a + b schreiben.

In C++ sind Operatoren im Wesentlichen Funktionen mit speziellen Namen. Um einen Operator zu überladen, definieren Sie eine Funktion unter Verwendung des Schlüsselworts operator, gefolgt von dem Symbol:

class Vector2D {
    double x, y;
    
public:
    Vector2D(double x, double y) : x(x), y(y) {}
    
    // Den +-Operator überladen
    Vector2D operator+(const Vector2D& other) const {
        return Vector2D(x + other.x, y + other.y);
    }
};

Jetzt können Sie zwei Vektoren auf natürliche Weise addieren:

Vector2D v1(1.0, 2.0);
Vector2D v2(3.0, 4.0);
Vector2D v3 = v1 + v2;    // Ruft v1.operator+(v2) auf

Nicht alle Operatoren können überladen werden. Der Bereichsauflösungsoperator ::, der Elementzugriff ., der ternäre Operator ?: und sizeof können nicht überladen werden. Zusätzlich können Sie keine neuen Operatoren erstellen oder die Rangfolge eines Operators ändern – * wird immer vor + ausgewertet.

Operatoren können als Elementfunktionen (wie oben) oder als Nicht-Elementfunktionen implementiert werden. In den kommenden Lektionen werden Sie lernen, wann welcher Ansatz zu verwenden ist und wie man bestimmte Kategorien von Operatoren überlädt.

Aufgabe

Einfach

Lassen Sie uns eine Point-Klasse erstellen, die eine 2D-Koordinate darstellt und das Addieren von zwei Punkten mit dem +-Operator unterstützt. Dies ist Ihr erster Schritt in die Überladung von Operatoren – damit Ihre benutzerdefinierten Klassen mit vertrauten Operatoren funktionieren.

Sie werden zwei Dateien erstellen, um Ihren Code zu organisieren:

Point.h: Definieren Sie eine Point-Klasse, die x- und y-Koordinaten speichert (beide int). Ihre Klasse sollte Folgendes enthalten:
- Private Member für die x- und y-Koordinaten
- Einen Konstruktor, der x- und y-Werte entgegennimmt
- Getter getX() und getY() (beide const)
- Einen überladenen +-Operator, der zwei Punkte addiert und einen neuen Point mit den kombinierten Koordinaten zurückgibt
Der +-Operator sollte als Member-Funktion implementiert werden, die einen weiteren Point als const-Referenz entgegennimmt und einen neuen Point zurückgibt. Markieren Sie ihn als const, da er keinen der Operanden verändert.
main.cpp: Lesen Sie vier Ganzzahlen von der Eingabe ein (x1, y1, x2, y2 in separaten Zeilen), die zwei Punkte darstellen. Erstellen Sie zwei Point-Objekte, addieren Sie diese mit dem +-Operator und zeigen Sie die Ergebnisse an.
Ausgabeformat:
```
Point 1: (<x1>, <y1>)
Point 2: (<x2>, <y2>)
Sum: (<sum_x>, <sum_y>)
```

Die entscheidende Erkenntnis hierbei ist, dass p1 + p2 hinter den Kulissen eigentlich p1.operator+(p2) aufruft. Ihr überladener Operator ermöglicht es Ihnen, intuitiven Code wie Point p3 = p1 + p2; anstelle von etwas wie Point p3 = p1.add(p2); zu schreiben.

Konvertieren Sie Eingabestrings mit std::stoi() in Ganzzahlen. Vergessen Sie nicht die Header-Guards in Ihrer Header-Datei.

Probier es selbst

#include <iostream>
#include <string>
#include "Point.h"

using namespace std;

int main() {
    // Eingabe lesen
    string line1, line2, line3, line4;
    getline(cin, line1);
    getline(cin, line2);
    getline(cin, line3);
    getline(cin, line4);

    int x1 = stoi(line1);
    int y1 = stoi(line2);
    int x2 = stoi(line3);
    int y2 = stoi(line4);

    // TODO: Erstellen Sie zwei Point-Objekte unter Verwendung der Eingabewerte

    // TODO: Addieren Sie die beiden Punkte mit dem +-Operator

    // TODO: Geben Sie die Ergebnisse im erforderlichen Format aus:
    // Punkt 1: (<x1>, <y1>)
    // Punkt 2: (<x2>, <y2>)
    // Summe: (<sum_x>, <sum_y>)

    return 0;
}