Operator, Operatoren, Typanpassung, Typanpassungen, Typwandlung, Typwandlungen

Überladene Operatoren

Wir haben überladene Operatoren schon im Grundkurs kennengelernt.

main.cpp

#include <iostream> /* ::std::cout   */
#include <ostream>  /* <<            */
#include <string>   /* ::std::string */
using namespace ::std::literals;
int main()
{ ::std::cout << 1 + 2 << '\n';
  ::std::cout << "a"s + "b"s << '\n'; }

transcript

3
ab

Im allgemeinen ist ein überladener Operator ein Operator, dessen Implementation an Hand der Aufrufsignatur ausgewählt wird. Das heißt, daß für die Addition zweier Zahlen ein anderes Programm verwendet als die „Addition“ (Verkettung) zweier Zeichenfolgen.

Insbesonderen denkt man bei überladenen Operator an Operatoren, die eine spezielle Implementation (ein spezielles Programm) für Operanden eines benutzerdefinierten Typs haben.

Operatornamen

Der eigentliche Name einer Funktion besteht meist aus einer einzigen lexikalischen Einheit, nämlich einem Bezeichner, wie beispielsweise »rand«.

Der Name einer Funktion kann aber auch aus zwei lexikalischen Einheiten bestehen: Dem Bezeichner »operator« und einer lexikalischen Einheit für einen Operator, wie beispielsweise »+«. Es ist also beispielsweise möglich, als eigentlichen Funktionsnamen »operator +« (zwei lexikalische Einheiten) zu verwenden.

Dies ist jedoch nur bei Verwendung benutzerdefinierter Typen möglich. In dem folgenden Programm befindet sich der Funktionsname »operator +« im Namensraum »::std«.

main.cpp

#include <iostream> /* ::std::cout   */
#include <ostream>  /* <<            */
#include <string>   /* ::std::string */
using namespace ::std::literals;
int main()
{ ::std::cout << ::std::operator +( "a"s, "b"s )<< '\n'; }

transcript

ab

Die Schreibweise mit »operator« kann auch noch für weitere Operanden in unserem Programm verwendet werden.

main.cpp

#include <iostream> /* ::std::cout   */
#include <ostream>  /* <<            */
#include <string>   /* ::std::string */
using namespace ::std::literals;
int main()
{ ::std::operator <<( ::std::operator <<( ::std::cout, ::std::operator +( "c"s, "d"s )), '\n' ); }

transcript

cd

Dank ADL kann aber nun der Namensraum wieder weggelassen werden.

main.cpp

#include <iostream> /* ::std::cout   */
#include <ostream>  /* <<            */
#include <string>   /* ::std::string */
using namespace ::std::literals;
int main()
{ ::std::cout << operator +( "e"s, "f"s )<< '\n'; }

transcript

ef

»operator +« ohne Namensraum entspricht der Verwendung des Operators »+« in »"a"s + "b"s«. Bei der Schreibweise als Operator kann kein Namensraum angegeben werden. Die Verwendung des überladenen Operators »+« ist also nur dank ADL möglich!

Das folgende Programm zeigt noch einige Beispiele überladener Operatoren: Die eckigen Klammern wählen ein Zeichen einer Zeichenfolge aus. Da die eckigen Klammern aber den Zahlenwert nicht prüfen, sollte die Elementfunktionen mit dem Namen »at« bevorzugt werden. Andere Operatoren erlauben den Vergleich zweier Zeichenfolgen.

main.cpp

#include <iostream> /* ::std::cout   */
#include <ostream>  /* <<            */
#include <string>   /* ::std::string */
using namespace ::std::literals;
int main()
{ ::std::cout << "abc"s[ 1 ]<< '\n';
  ::std::cout << "abc"s.at( 2 )<< '\n';
  ::std::cout <<( "abc"s == "abc"s )<< '\n';
  ::std::cout <<( "abc"s < "abc"s )<< '\n';  }

transcript

b
c
1
0

Auch Vektoren unterstützen die eben vorgestellten Operatoren.

main.cpp

#include <iostream> /* ::std::cout   */
#include <ostream>  /* <<            */
#include <vector>   /* ::std::vector */
int main()
{ ::std::vector< int >v{ 1, 2, 3 };
  ::std::vector< int >w{ 1, 2, 4 };
  ::std::cout << v[ 1 ]<< '\n';
  ::std::cout << v.at( 2 )<< '\n';
  ::std::cout <<( v == w )<< '\n';
  ::std::cout <<( v < w )<< '\n';  }

transcript