Operatorüberladung in C++

In C++ ermöglicht das Operator-Overloading (Operatorüberladung) die Neudefinition von Standardoperatoren (+, ==, <, << usw.) für benutzerdefinierte Klassentypen. Dadurch können Klassenobjekte wie eingebaute Typen (int, double usw.) verwendet werden. In diesem Artikel werden wir anhand der Book-Klasse arithmetische, Vergleichs- und Stream-Operatoren praxisnah untersuchen.

1. Was ist Operatorüberladung?

Mit Operatorüberladung kann man einem Operator ein spezielles Verhalten für eine Klasse geben. Zum Beispiel können zwei Book-Objekte mit + kombiniert oder mit == verglichen werden.

Operatorfunktionen werden wie normale Memberfunktionen definiert:

class KlassenName {
public:
    Rückgabewert operator<Operator>(Parameter) {
        // spezielles Verhalten
    }
};

Zum Beispiel bedeutet Book operator+(const Book& other), dass zwei Book-Objekte den +-Operator unterstützen.

2. Grundlegende Book-Klasse

Die folgende Klasse repräsentiert ein Buch mit Titel, Preis und Seitenzahl. Auf dieser Basis werden wir verschiedene Operatoren definieren.

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

class Book {
private:
    string title;
    double price;
    int pages;

public:
    Book(string t = "", double p = 0.0, int pg = 0)
        : title(t), price(p), pages(pg) {}

    void Show() const {
        cout << "Buch: " << title
             << " | Seiten: " << pages
             << " | Preis: " << price << " €" << endl;
    }

    double GetPrice() const { return price; }
    int GetPages() const { return pages; }
    string GetTitle() const { return title; }
};

3. Der + Operator (Bücher kombinieren)

Wenn wir zwei Bücher mit + kombinieren, soll ein neues „Paket“-Buch entstehen. Der Preis ist die Summe der beiden Preise, und die Seitenzahl die Summe der Seiten.

Book operator+(const Book &other) const {
    string combinedTitle = title + " & " + other.title;
    double combinedPrice = price + other.price;
    int combinedPages = pages + other.pages;
    return Book(combinedTitle, combinedPrice, combinedPages);
}

Verwendung:

Book b1("C++ Primer", 180.0, 980);
Book b2("Effective C++", 150.0, 400);

Book combo = b1 + b2;
combo.Show();

Ausgabe:

Buch: C++ Primer & Effective C++
| Seiten: 1380 | Preis: 330 €

4. Der == Operator (Gleichheitsvergleich)

Um zu prüfen, ob zwei Bücher gleich sind, kann der ==-Operator überladen werden. Wenn Titel, Preis und Seitenzahl übereinstimmen, gelten sie als gleich.

bool operator==(const Book &other) const {
    return (title == other.title &&
            pages == other.pages &&
            price == other.price);
}

Verwendung:

Book a("1984", 99.9, 328);
Book b("1984", 99.9, 328);

if (a == b)
    cout << "Bücher sind gleich." << endl;
else
    cout << "Bücher sind unterschiedlich." << endl;

Ausgabe:

Bücher sind gleich.

5. Der < Operator (Vergleich)

Um Bücher nach Preis zu vergleichen, kann der <-Operator überladen werden. Dieser Operator wird z. B. von std::sort() oder std::set verwendet.

bool operator<(const Book &other) const {
    return price < other.price;
}

Verwendung:

Book b1("C++ Primer", 180, 900);
Book b2("Clean Code", 220, 500);

if (b1 < b2)
    cout << b1.GetTitle() << " ist günstiger." << endl;

Ausgabe:

C++ Primer ist günstiger.

6. Der ++ Operator (Seitenzahl erhöhen)

Der ++-Operator kann als Präfix oder Postfix definiert werden. In diesem Beispiel erhöht er die Seitenzahl eines Buchs.

// Präfix (++buch)
Book& operator++() {
    ++pages;
    return *this;
}

// Postfix (buch++)
Book operator++(int) {
    Book temp = *this;
    pages++;
    return temp;
}

Verwendung:

Book b("C++ 101", 120.0, 250);
++b;  // Präfix
b++;  // Postfix
b.Show(); // 252 Seiten

7. Der << Operator (Ausgabe mit ostream)

Wenn man ein Objekt direkt mit cout << b; ausgeben möchte, muss der <<-Operator global überladen werden. Er gibt in der Regel eine Referenz auf ostream zurück.

friend ostream& operator<<(ostream &os, const Book &b) {
    os << "[Buch: " << b.title
       << ", Seiten: " << b.pages
       << ", Preis: " << b.price << " €]";
    return os;
}

Verwendung:

Book b("Clean Architecture", 175.0, 350);
cout << b << endl;

Ausgabe:

[Buch: Clean Architecture, Seiten: 350, Preis: 175 €]

8. Vollständiges Beispiel: Alle Operatoren kombiniert

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

class Book {
private:
    string title;
    double price;
    int pages;

public:
    Book(string t = "", double p = 0, int pg = 0)
        : title(t), price(p), pages(pg) {}

    Book operator+(const Book &other) const {
        return Book(title + " & " + other.title,
                    price + other.price,
                    pages + other.pages);
    }

    bool operator==(const Book &other) const {
        return (title == other.title && price == other.price);
    }

    bool operator<(const Book &other) const {
        return price < other.price;
    }

    Book& operator++() {
        ++pages;
        return *this;
    }

    Book operator++(int) {
        Book temp = *this;
        pages++;
        return temp;
    }

    friend ostream& operator<<(ostream &os, const Book &b) {
        os << b.title << " - " << b.price << " € (" << b.pages << " Seiten)";
        return os;
    }
};

int main() {
    Book b1("C++ Primer", 180.0, 900);
    Book b2("Effective C++", 150.0, 400);

    Book combo = b1 + b2;
    cout << combo << endl;

    ++combo;
    combo++;

    cout << "Nach Erhöhung: " << combo << endl;

    cout << (b1 < b2 ? "b1 ist günstiger" : "b2 ist günstiger") << endl;

    if (b1 == b2)
        cout << "Bücher sind gleich." << endl;
    else
        cout << "Bücher sind unterschiedlich." << endl;
}

Ausgabe:

C++ Primer & Effective C++ - 330 € (1300 Seiten)
Nach Erhöhung: C++ Primer & Effective C++ - 330 € (1302 Seiten)
b1 ist günstiger
Bücher sind unterschiedlich.

9. TL;DR

Ähnliche Artikel