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 dir, festzulegen, wie sich Operatoren wie +, - oder == verhalten, wenn sie mit deinen eigenen Klassen verwendet werden. Anstatt Methoden wie a.add(b) aufzurufen, kannst du die intuitivere Schreibweise a + b verwenden.

In C++ sind operators im Wesentlichen Funktionen mit speziellen Namen. Um einen operator zu überladen, definierst du eine Funktion mit dem Schlüsselwort operator, gefolgt vom Symbol:

class Vector2D {
    double x, y;
    
public:
    Vector2D(double x, double y) : x(x), y(y) {}
    
    // Überlade den + Operator
    Vector2D operator+(const Vector2D& other) const {
        return Vector2D(x + other.x, y + other.y);
    }
};

Jetzt kannst du zwei Vektoren ganz natürlich 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 member-Zugriff ., der ternäre Operator ?: und sizeof können nicht überladen werden. Außerdem kannst du keine neuen Operatoren erstellen oder die Priorität eines Operators ändern – * wird immer vor + ausgewertet.

Operatoren können als member-Funktionen (wie oben) oder als Nicht-member-Funktionen implementiert werden. In den kommenden Lektionen lernst du, wann du welchen Ansatz verwenden solltest und wie du bestimmte Kategorien von Operatoren überlädst.

Aufgabe

Einfach

Erstellen wir eine Point-Klasse, die eine 2D-Koordinate darstellt und das Addieren zweier Punkte mithilfe des +-Operators unterstützt. Dies ist dein erster Schritt in die Operatorüberladung, durch die deine eigenen Klassen mit vertrauten Operatoren funktionieren.

Du erstellst zwei Dateien, um deinen Code zu organisieren:

Point.h: Definiere eine Point-Klasse, die x- und y-Koordinaten (beide int) speichert. Deine 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 Memberfunktion implementiert werden, die einen anderen Point als konstante Referenz entgegennimmt und einen neuen Point zurückgibt. Markiere ihn als const, da er keinen der beiden Operanden verändert.
main.cpp: Lies vier Ganzzahlen aus der Eingabe (x1, y1, x2, y2 in separaten Zeilen), die zwei Punkte darstellen. Erstelle zwei Point-Objekte, addiere sie mithilfe des +-Operators und gib die Ergebnisse aus.
Ausgabeformat:
```
Point 1: (<x1>, <y1>)
Point 2: (<x2>, <y2>)
Sum: (<sum_x>, <sum_y>)
```

Die wichtigste Erkenntnis hierbei ist, dass p1 + p2 hinter den Kulissen tatsächlich p1.operator+(p2) aufruft. Dein überladener Operator ermöglicht es dir, intuitiven Code wie Point p3 = p1 + p2; zu schreiben, statt etwas wie Point p3 = p1.add(p2);.

Konvertiere Eingabezeichenfolgen mithilfe von std::stoi() in Ganzzahlen. Vergiss die Header-Guards in deiner Header-Datei nicht.

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: Erstelle zwei Point-Objekte mit den Eingabewerten

    // TODO: Addiere die beiden Punkte mit dem + Operator

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

    return 0;
}