HI
Operatorüberladung von unären Operatoren am Beispiel von ++
Als Ergänzung zum vorigen Artikel über Operatorüberladung möchte ich mich hier speziell dem Operator ++ widmen. Da er (bei Deklaration auf Klassenebene) bei der Benutzung keine weiteren Parameter besitzt (deswegen ja unär), sind die exakten Typdeklarationen gerade im Zusammenhang mit Post- und Präfixschreibweise (z.B X++ oder ++X) oft unkar.
Normalerweise geht C++ immer davon aus, dass man den ++ Operator als Präfix - also vor der Variable - benutzt!
Will man C++ dazu brigen, den Operator auch nach der Variablen zu aktzeptieren, muss man einen Trick benutzen. Wenn man so tut als wäre der ++ Operator binär und deshalb noch einen weiteren Parameter mit in der Deklaration angibt (am besten int), sucht der Compiler nach einem Ausdruck der Form X++I (I als Integervariable angenommen). Benutz man jetzt den Operator als Postfix in der Art X++; begeht man strenggenommen eigentlich einen Fehler, weil man die deklarierte Integervariable unterschlägt. Jedoch nimmt dies der Compiler in aller Regel trotzdem als richtigen Ausdruck hin.
Jetzt aber wie versprochen zu den Typdeklarationen:
Zunächst der einfach Fall mit der Schreibweise ++X :
Hier soll ja eine bestimmte (typabhängige) Eigenschaft des Objektes X erhöhen, und zwar bevor der übergeordnete Ausdruck ausgewertet wird. Wenn z.B. Y=++X; im Quelltext steht, soll hier X erhöht werden bevor es Y zugewiesen wird. Aus diesem Grund werden wir so vorgehen, dass wir in der Operatorfunktion zunächst den Wert erhöhen und dann eine Referenz auf das eigene Objekt zurückgeben, damit der folgende Ausdruck mit dem neu festgelegtem Wert arbeiten kann.
Beispiel:
Mal angenommen unsere Klasse hieße CKonto und wir wollten den Kontostand mit ++ um eine DM erhöhen, dann könnte man z.B. folgende Operatorüberladung in der Klasse vornehmen:
class CKonto
{
public: ..........
CKonto& operator++();
private: ..........
long DM;
int Pfennige;
};
CKonto& CKonto:
perator++()
{
DM=DM+1; //erhöht den Kontostand
return (*this); //gibt eine Referenz auf das eigene Objekt zurück,
// da der Zeiger auf das eig.Objekt (this) mit * derefferenziert wird
}
Wie man sieht also gar nicht so kompliziert!
Jetzt aber zu der Schreibweise X++:
Wie vorhin beschrieben benutzen wir hier den Trick mit dem zusätzlichen Parameter. Aber dennoch gilt es noch ein Problem zu lösen. Der nachgestellte ++ Operator soll ja bewirken, dass die Erhöhung erst nach dem auswerten des übergeordneten Ausdrucks geschieht. Wenn man Y=X++; verwendet, soll erst X dem Y zugewiesen werden, und dann X erhöht werden.
Dieses Problem lösen wir, indem wir dem übergeordneten Ausdruck eine Kopie von dem eigenen Objekt übergeben, bevor wir in der Operatorfunktion den Wert verändern.
Konkret sieht das dann so aus:
class CKonto
{
public: ..........
CKonto operator++(int);
private: ..........
long DM;
int Pfennige;
};
CKonto CKonto:
perator++(int pseudoparameter)
{
CKonto Kopie=(*this); //legt die Kopie vom ursprünglichen Zustand an
DM=DM+1; //erhöht den Kontostand vom eigenen Objekt
return Kopie; //gibt unberührte Kopie zurück
}
Beim Aufruf Y=X++; (X,Y Instanzen der Klasse CKonto) wird zwar der Kontostand zuerst erhöht, jedoch bekommt die Zuweisung an Y nur eine Kopie, die noch nicht erhöht wurde (also etwa Y=<Kopie von X vor Veränderung> ).
Genauso funktioniert das natürlich auch mit dem -- Operator, wenn man die Werte vermindern will.
QUELLE: Keine Angabe da die Seite mitlerweile OFF ist.
MfG
inbluedeep
