Operatorüberladung
Lerne, wie du Operatoren korrekt überlädst — Member vs. Nicht-Member, kanonische Formen, Stream-Operatoren, den Raumschiff-Operator aus C++20 und die häufigsten Fallstricke.
Die Philosophie der Operatorüberladung
C++ erlaubt dir festzulegen, wie Operatoren (+, ==, <<, [] usw.) für deine eigenen Typen funktionieren. Die goldene Regel: Mach es so, wie die ints es tun. Überladene Operatoren sollten sich so verhalten, wie Nutzer es von eingebauten Typen erwarten. Wenn a + b das a verändert, hast du die Erwartungen deiner Nutzer gebrochen.
Operatorüberladung ist der Grund, warum sich Typen wie std::string, std::vector und std::complex so natürlich anfühlen. Schlecht eingesetzt erzeugt sie jedoch verwirrenden, unwartbaren Code. Überlade Operatoren niemals so, dass sie etwas Überraschendes tun.
Member- vs. Nicht-Member-Operatoren
Manche Operatoren müssen Member sein (=, [], ->, ()). Andere sind als Nicht-Member besser aufgehoben (insbesondere binäre Operatoren wie + und ==), weil so symmetrische Konvertierungen möglich sind. Das kanonische Muster: Implementiere += als Member und darauf aufbauend + als Nicht-Member.
#include <iostream>
class Vec2 {
double x_, y_;
public:
Vec2(double x = 0, double y = 0) : x_{x}, y_{y} {}
// += is a member: modifies *this
Vec2& operator+=(const Vec2& rhs) {
x_ += rhs.x_;
y_ += rhs.y_;
return *this;
}
// Unary minus (member)
Vec2 operator-() const {
return Vec2{-x_, -y_};
}
// Accessors for non-member operators
double x() const { return x_; }
double y() const { return y_; }
// [] operator (must be member)
double& operator[](int i) {
return i == 0 ? x_ : y_;
}
const double& operator[](int i) const {
return i == 0 ? x_ : y_;
}
};
// + is a non-member using += (canonical form)
Vec2 operator+(Vec2 lhs, const Vec2& rhs) { // lhs by value!
lhs += rhs;
return lhs;
}
// == as non-member (symmetric: allows conversions on both sides)
bool operator==(const Vec2& a, const Vec2& b) {
return a.x() == b.x() && a.y() == b.y();
}
// Stream output operator (must be non-member)
std::ostream& operator<<(std::ostream& os, const Vec2& v) {
return os << '(' << v.x() << ", " << v.y() << ')';
}
int main() {
Vec2 a{1.0, 2.0}, b{3.0, 4.0};
Vec2 c = a + b; // uses non-member operator+
std::cout << c << '\n'; // (4, 6)
std::cout << -c << '\n'; // (-4, -6)
std::cout << c[0] << '\n'; // 4
std::cout << std::boolalpha << (a == b) << '\n'; // false
return 0;
}Der Raumschiff-Operator aus C++20 (<=>)
C++20 führt den Drei-Wege-Vergleichsoperator <=> ein (den "Raumschiff-Operator"). Eine einzige Definition von operator<=> erzeugt automatisch alle sechs Vergleichsoperatoren (<, >, <=, >=, ==, !=). Verwende = default, wenn ein memberweiser Vergleich genau das ist, was du willst.
#include <iostream>
#include <compare>
#include <string>
class Version {
int major_;
int minor_;
int patch_;
public:
Version(int major, int minor, int patch)
: major_{major}, minor_{minor}, patch_{patch} {}
// Defaulted <=>: compares members in declaration order
auto operator<=>(const Version&) const = default;
friend std::ostream& operator<<(std::ostream& os, const Version& v) {
return os << v.major_ << '.' << v.minor_ << '.' << v.patch_;
}
};
class Student {
std::string name_;
double gpa_;
public:
Student(const std::string& name, double gpa)
: name_{name}, gpa_{gpa} {}
// Custom <=>: compare only by GPA
auto operator<=>(const Student& other) const {
return gpa_ <=> other.gpa_;
}
// Need separate == if <=> is not defaulted
bool operator==(const Student& other) const {
return gpa_ == other.gpa_;
}
friend std::ostream& operator<<(std::ostream& os, const Student& s) {
return os << s.name_ << " (GPA: " << s.gpa_ << ')';
}
};
int main() {
Version v1{2, 0, 0}, v2{1, 9, 5};
std::cout << v1 << " > " << v2 << "? "
<< std::boolalpha << (v1 > v2) << '\n'; // true
std::cout << (v1 == v2) << '\n'; // false
Student alice{"Alice", 3.9};
Student bob{"Bob", 3.7};
std::cout << (alice > bob) << '\n'; // true (higher GPA)
return 0;
}operator() — Funktionsobjekte
Das Überladen von operator() erzeugt einen Funktor (ein Funktionsobjekt). Funktoren können Zustand halten und sind damit flexibler als einfache Funktionszeiger. Sie werden ausgiebig zusammen mit STL-Algorithmen eingesetzt.
#include <iostream>
#include <vector>
#include <algorithm>
// A functor that counts how many times it's called
class Counter {
int count_ = 0;
int threshold_;
public:
explicit Counter(int threshold) : threshold_{threshold} {}
bool operator()(int value) {
++count_;
return value > threshold_;
}
int calls() const { return count_; }
};
int main() {
std::vector<int> nums{1, 5, 3, 8, 2, 9, 4, 7, 6};
Counter above_five{5};
auto count = std::count_if(nums.begin(), nums.end(), above_five);
std::cout << count << " elements above 5\n"; // 4
// Functors can also be used directly
Counter is_positive{0};
std::cout << std::boolalpha;
std::cout << is_positive(42) << '\n'; // true
std::cout << is_positive(-1) << '\n'; // false
std::cout << "Calls: " << is_positive.calls() << '\n'; // 2
return 0;
}Überlade Operatoren nicht so, dass sie überraschende Dinge tun. operator+ sollte addieren, nicht subtrahieren. operator* auf einer Matrix sollte eine Matrixmultiplikation durchführen, keine elementweise Multiplikation (außer deine Domäne erwartet genau das). Manche Operatoren können nicht überladen werden: ::, ., .*, ?: und sizeof. Außerdem verlieren && und || beim Überladen die Kurzschlussauswertung — das ist fast nie eine gute Idee.
Halte dich an die kanonischen Formen: Implementiere zusammengesetzte Zuweisungen (+=, -=) als Member und definiere darauf aufbauend die binären Operatoren (+, -) als Nicht-Member. Implementiere immer operator==, wenn du operator< implementierst (oder besser: nutze <=> aus C++20, um alle sechs zu bekommen). Implementiere Stream-Operatoren (<<, >>) als Nicht-Member-friends. Verwende explicit bei Konvertierungsoperatoren, um versehentliche implizite Konvertierungen zu verhindern.
- Folge dem Grundsatz "Mach es so, wie die ints es tun" — Operatoren sollten sich so verhalten, wie Nutzer es erwarten
- Implementiere die zusammengesetzte Zuweisung (
+=) als Member und+darauf aufbauend als Nicht-Member - Das
operator<=>aus C++20 erzeugt aus einer einzigen Definition alle sechs Vergleichsoperatoren - Das Überladen von
operator()erzeugt Funktoren — Objekte, die sich wie Funktionen aufrufen lassen &&und||verlieren beim Überladen die Kurzschlussauswertung — überlade sie besser nicht- Manche Operatoren lassen sich nicht überladen:
::,.,.*,?:,sizeof
Quiz — Teste dein Wissen
(15 XP)1. Warum wird `operator+` typischerweise als Nicht-Member-Funktion implementiert?
2. Was bewirkt `auto operator<=>(const T&) const = default;` in C++20?
3. Warum solltest du `operator&&` und `operator||` nicht überladen?