LOGIN | NEU REGISTRIEREN

Schule > Informatik > Programmiersprachen > C und C++ > Referenztypen u. Operatoren in C++

Referenztypen

Um bei der Parameterübergabe bei Funktionen die Parameterwerte ändern zu können, ist es notwendig, die Parameter call-by-reference aufzurufen. Dies bedeutet, dass der Datentyp des formalen Parameters ein Zeiger sein muss, der Aufruf des aktuellen Parameters erfolgt mit dem Adressoperator.

Beispiel:
Deklaration void betrag (float *zahl);
Funktionskopf void betrag (float *zahl)
.....
Aufruf int absolut;
...

betrag ( &absolut);

Für den Aufruf eines Operators hätte dies zur Folge, dass ein call-by-reference-Aufruf etwa so aussehen müsste:
summe = &operand1 + &operant2;
Diesen Aufruf mittels des Adressoperators kann man umgehen, indem man statt des Zeigertyps den Referenztyp benutzt. Hierbei wird für einen existierenden Speicherplatz eine neuer, zweiter Name vergeben.

Beispiel:
int a; Definition einer Variablen vom Typ int.
Int &b = a; a bekommt als 2. Namen b. Dies geht nur für
bereits bestehende Variablen. Die Zuweisung einer Referenz an einen Referenzparameter kann nur bei der Definition des Apeicherplatzes vorgenommen werden.

Beispiel in Verbindung mit Funktionen:
Deklaration void betrag (int &wert);
Definition void betrag (int &wert)
....
Aufruf int a;
....

betrag(a);
Dadurch wird erreicht, dass ein Parameter auch ohne Adressoperator als call-by-reference aufgerufen werden kann. Das begünstigt das Programmieren.

Überladen von Operatoren

Bei der Definition einer Klasse ist es selten möglich, die Operatoren in ihrer bisherigen Form zu benutzen, da die zugrunde liegenden Daten durch die Klasse selbst definiert sind. So gibt es zum Beispiel keinen Operator * für die Multiplikation von zwei Brüchen, die als eigene klasse definiert sind. Daher ist es eigentlich nur möglich, eine Multiplikation von zwei Brüchen als Methode der Klasse zu definieren:
class BRUCH
int zaehler,
nenner;

public:
BRUCH(); // Konstuktor
BRUCH multipliziere_mit(BRUCH b);
};
BRUCH BRUCH::multipliziere_mit(BRUCH b)
BRUCH produkt;
produkt.zaehler = zaehler * b.zaehler;
produkt.nenner = nenner * b.nenner;
return produkt;

Der Aufruf im Hauptprogramm könnte dann wie folgt aussehen:
...
BRUCH a,b,p;
...

p = a.multipliziere_mit(b);

Dieser Aufruf ist sehr kompliziert und verdeutlicht eigentlich nicht die Multiplikation. Es wäre gut, wenn man statt dessen wie gewohnt die Multiplikation der Brüche mit dem Operator * aufrufen könnte:

p = a * b;

Dazu muss der Operators * überladen werden, d.h. er erhält eine neue, selbstdefinierte Funktion. Dabei gibt es zwei Möglichkeiten:
Der Operator ist Methode der Klasse, dann ist er an ein Objekt gebunden.
Der Operator ist keine Methode der Klasse und somit nicht an ein Objekt gebunden. Dann benötigt der Operator zwei Faktoren als Parameter. Damit der Operator dann weiterhin auf die geschützten Attribute der Klasse Bruch zugreifen kann, muss er mit der Klasse befreundet werden. Die Attribute müssen dann protected geschützt werden.

Operator als Methode der Klasse:
class BRUCH
int zaehler,
nenner;

public:
BRUCH();
BRUCH operator *(BRUCH b);
};
BRUCH BRUCH: : operator *(BRUCH b)
BRUCH produkt;
produkt.zaehler = zaehler * b.zaehler;
produkt.nenner = nenner * b.nenner;
return produkt;
Da der Operator * Methode der Klasse BRUCH ist, kann er auch auf die privaten Attribute der Klasse zugreifen, auch wenn dies die Attribute eines anderen Objektes der Klasse ist. Hier ist dies z. B. der Zugriff auf das Attribut Zaehler des Objekts b der Fall.

Operator außerhalb der Klasse:
class BRUCH

protected:
int zaehler,
nenner;

public:
BRUCH();
friend BRUCH operator *(BRUCH a, BRUCH b);
};
BRUCH operator *(BRUCH a, BRUCH b)
BRUCH produkt;
produkt.zaehler = a.zaehler * b.zaehler;
produkt.nenner = a.nenner * b.nenner;
return produkt;
Hier ist der Operator keine Methode der Klasse. Um auf die Attribute der Klasse ohne eine lesende Methode zugreifen zu können, wird der Operator mit der Klasse befreundet. Dies geschieht in der Klassendefinition durch eine Deklaration mit vorangestelltem Schlüsselwort friend.
Der Aufruf des Operators ist in beiden Fällen: p = a * b; oder p = a * b * c;

Ausgabeoperator <<
Der Ausgabeoperator << ist eine Methode der Standardklasse ostream, die für die Ausgaben auf den Bildschirm zuständig ist. Ein Objekt der Klasse, das automatisch angelegt wird, ist cout. Für die selbsterstellte Klasse BRUCH ist der Operator << nicht definiert. Daher muss die Ausgabe eines Objektes der Klasse BRUCH z.B. mit einer Methode print() erfolgen.

Auch hier wäre es schön, wenn der Operator << für die selbstdefinierte Klasse überladen werden kann. Dies geht auch, allerdings nicht als Methode der Klasse, da dieser ja bereits zu der Klasse ostream gehört, die selbst nicht verändert werden kann. Ein Überladen ist also nur außerhalb der Klasse möglich. Dies bedeutet wiederum eine "Freundschaft" für die Klasse BRUCH.
class BRUCH

protected:
int zaehler,
nenner;

public:
BRUCH();
friend BRUCH operator *(BRUCH a, BRUCH b);
friend void operator <<(ostream & out, BRUCH b);
};
void operator <<(ostream &out, BRUCH b)
out << b.zaehler << '/' << b.nenner;
Der Operator << hat als ersten Parameter einen Referenzparameter vom Typ ostream&. Dies ist für diesen Operator vorgegeben. Der Name des formalen Parameters, hier out, kann beliebig gewählt werden. Erst beim Aufruf des Operators wird dieser mit dem aktuellen Parameter cout verbunden.
BRUCH a;
...

cout << a;
Ein mehrfacher hintereinandergeschalteter Aufruf von << ist bei der obigen Definition nicht möglich, da der Operator keinen Rückgabewert (void) hat, der als erneuter Parmeter dienen kann. Um diese zu ermöglichen, muss der Operator einen Rückgabewert vom Typ ostream & haben.
class BRUCH
...
friend ostream & operator <<(ostream & out, BRUCH b);
};
ostream & operator <<(ostream &out, BRUCH b)
out << b.zaehler << '/' << b.nenner;
return out;
Leistungskurs Informatik 12.1 Eck

Download: PDF, DOC