C++ Operatoren überladen

Operator ==

Nützlich, wenn man eigene Klassen auf Gleichheit überprüfen möchte. Als Beispiel verwende ich die Klasse Bruch, bei der true zurückgegeben wird, wenn Zähler und Nenner übereinstimmen.

bool Bruch::operator == (const Bruch& other)
{
	return ((zaehler == other.zaehler) && (nenner == other.nenner));
}

Operator !=

Falls man bereits den == Operator definiert hat, gibt es den != Operator beinahe gratis dazu:

bool Bruch::operator != (const Bruch& other)
{
	return !(*this == other);
}

Zuweisungs Operator =

Ganz wichtig ist, zu prüfen of eine Selbstzuweisung erfolgt (z.B. c = c; ), besonders wenn die eigene Klasse selbst Speicher alloziert.

Bruch& Bruch::operator = (const Bruch& rhs)
{
	if (this == &rhs) {
		return *this;
	}
	// 1.  Deallocate any memory that MyClass is using internally
	// 2.  Allocate some memory to hold the contents of rhs
	// 3.  Copy the values from rhs into this instance
	// 4.  Return *this
	return *this;
}

Der Rückgabewert ist eine Referenz, damit Verkettungen wie a = b = c = 5; möglich sind. Er ist absichtlich nicht const, damit etwas wie (a = b) = c; funktioniert. Das mag zwar unsinnig erscheinen, funktioniert aber mit int - und da sich manche Tools anscheinend auf dieses Verhalten verlassen, ist es hier wichtig, eine nicht-const Referenz zurückzugeben.

Compound Assignment Operator += -= *=

Bruch& Bruch::operator += (const Bruch& rhs)
{
	// Do the compound assignment.
	return *this;
}

Der Rückgabewrt ist nicht const, damit etwas wie (a += 5) += 3; funktioniert. Im Allgemeinen gelten hier die gleichen Überlegungen bezüglich Selbstzuweisung, die auch für den Zuweisungsoperator gelten.

Binäre Arithmetik Operatoren + - * /

Man kann sich hier viel Arbeit sparen, indem man auf die Compound Assignment Operatoren zurückgreift ;-)

const Bruch Bruch::operator + (const Bruch& other) const
{
	Bruch result = *this;	// Eine Kopie erstellen. Ist das Gleiche wie Bruch result(*this);
	result += other;
	return result;
	// Alternativ in einer einzigen Zeile, aber schwerer zu lesen:
	return Bruch(*this) += other;
}

Der Rückgabewrt ist hier const, damit etwas wie (a + b) = c; sich NICHT compilieren lässt, da es ohnehin nicht funktioniert.

Operator <=> (ab C++20)

Durch Überladen dieses Operators kann man sich die Definition der meisten anderen Vergleichsoperatoren schenken, da der Compiler diese in Ausdrücke mit dem Spaceship Operator umwandeln kann.

auto operator <=> (const MyClass& rhs) const = default;
{
}