Tutorium Software-Engineering SS14 Florian Manghofer

Überladen von Operatoren Operatoren (+,-,*, /, usw.) können überschrieben/überladen werden Je nachdem auf welche Operanden der Operator angewandt wird, kann dieser für diesen speziellen Fall überschrieben werden Bsp. int a, b = 5; cout << a + b;//Ergebnis:10,Normales Plus Zeichen bei komplexen Zahlen geht das normale Plus nicht. C++ kennt keinen Datentyp für Komplexe Zahlen und daher weiß der + Operator auch nicht, wie er Komplexe Zahlen „addieren“ soll. Für diesen Fall muss der + Operator, wenn die Operanden Objekte vom Typ komplexe Zahl (Klasse muss selbst geschrieben werden) sind, überschrieben werden. Könnte dann so aussehen(selbstgeschriebene Klasse Komplex): Komplex k(„3“,“5“); Komplex g(„4“,“6“); Komplex b = g + k; Der + Operator könnte hier so überladen sein, dass er jeweils Imaginärteil und Realteil der beiden komplexen Zahlen addiert, mit diesen Werten ein neues Komplex Objekt erzeugt und dieses zurückgibt.

Überladen von Operatoren cout << b; Würde auf anhieb so nicht klappen, weil << auch ein Operator ist und für den Typ Komplex Standardmäßig nicht definiert ist. Überschreibt man diesen für den Typ Komplex könnte die Ausgabe so aussehen: cout << b;// i Aber Vorsicht: Nicht überladbare Operatoren. ::.* Zugriffsoperatoren ?: Auswahloperator Die Funktionen bzw. Methoden zum überladen können innerhalb oder außerhalb der Klasse definiert werden. Allerdings sollten sie in der Regel als Funktionen, also außerhalb der Klasse definiert werden. Dann ist jedoch zu beachten, dass die Funktion Zugriff auf die Klassenattribute hat. Entweder über das Schlüsselwort friend, oder mit Getter bzw. Setter Methoden. Es gibt allerdings auch Operatoren, die müssen in der Klasse definiert werden. Nicht zu verwechseln, in der Klasse definieren bedeutet entweder wirklich in der Klasse, oder außerhalb zur Klasse gehörend ( Komplex::operator+ … z.B.)

Überladen von Operatoren Rückgabetyp operator op(Parameterliste); Syntax: Beispiel: Tisch operator+ (Platte p, Beine b);

Überladen von Operatoren Konkrete Implementierung des Beispiels: class Komplex{ private: float r; float i; public: Komplex(float rr, float ii):r(rr),i(ii){}; friend Komplex operator+(Komplex,Komplex); }; Komplex operator+ (Komplex a, Komplex b){ float r,i; r = a.r + b.r;//Realteile addieren i = a.i + b.i;//Imaginärteile addieren Komplex erg(r,i); //aus Ergebnis neues Objekt return erg; } Überladen außerhalb der Klasse Sonst hat die Funktion Keinen direkten Zugriff auf die Attribute

Überladen von Operatoren Konkrete Implementierung des Beispiels (ohne friend): class Komplex{ private: float r; float i; public: Komplex(float rr, float ii):r(rr),i(ii){}; float getR(){ return this.r;} float getI(){ return this.i;} }; Komplex operator+ (Komplex a, Komplex b){ float r,i; r = a.getR() + b.getR();//Realteile addieren i = a.getI() + b.getI();//Imaginärteile addieren Komplex erg(r,i); //aus Ergebnis neues Objekt return erg; }

Überladen von Operatoren class Komplex{ private: float r; float i; public: Komplex(float rr, float ii):r(rr),i(ii){}; float getR(){ return this.r;} float getI(){ return this.i;} }; Komplex* operator+ (Komplex a, Komplex b){ return new Komplex(a.getR() + b.getR(), a.getI() + b.getI()); } Konkrete Implementierung des Beispiels (mit Zeiger):

Überladen von Operatoren int main(){ Komplex k(12,3.4); Komplex g(2,1.2); Komplex b = k + g; //Ohne Zeiger, in b hat die Werte r = 14 und i = 4.6 Komplex *z = k + g; //Mit Zeiger, selbiges Ergebnis } Konkrete Implementierung des Beispiels:

Überladen von Operatoren Konkrete Implementierung des Beispiels (innerhalb Methode): class Komplex{ private: float r; float i; public: Komplex(float rr, float ii):r(rr),i(ii){}; float getR(){ return this.r;} float getI(){ return this.i;} }; Komplex Komplex::operator+ (Komplex a){ float r,i; r = this.r + a.getR();//Realteile addieren i = this.i+ a.getI(); //Imaginärteile addieren Komplex erg(r,i); //aus Ergebnis neues Objekt return erg; } Innerhalb der Methode definiert (aber außerhalb Implementiert) Funktion ist die gleiche wie vorher Unterschied: Der linke Operand ist immer das aktuelle Objekt, deshalb brauchen wir nun Nur noch einen Parameter beim Überladen angeben.

Überladen von Operatoren Konkrete Implementierung des Beispiels (innerhalb Methode): int main(){ Komplex k(12,3.4); Komplex g(2,1.2); Komplex b = k + g; //b hat die Werte r = 14 und i = 4.6 //analog gilt jedoch(da Klassenfunktion von Komplex Komplex b = k.operator+(g); //Jedoch viel umständlicher } Folgende Operatoren müssen als Methoden der Klasse deklariert sein: Operator Bedeutung = Zuweisung [ ] Indexoperator ( ) Funktionsaufruf -> Elementzugriff für Zeiger Diese Operatoren benötigen als linken Operanden immer einen sogenannten L-Wert, d.h. ein Objekt, das eine Adresse im Hauptspeicher hat.

Überladen von Operatoren cout << b; //Funktioniert noch nicht Überladen von <<: Syntax: ostream& operator<< (ostream& os, const TYP& a); In unserem Beispiel sieht dass dann so aus (als Funktion) : ostream& operator<< (ostream &os, const Komplex& a){ os << a.getR() << „ + “ << a.getI() << „i“; return os; } int main(){ Komplex k(12,3.4); Komplex g(2,1.2); Komplex b = k + g; //Ohne Zeiger, in b hat die Werte r = 14 und i = 4.6 cout << b;//Ausgabe: i }

Überladen von Operatoren cout >> neueKomplex; //Funktioniert noch nicht Überladen von >>: Syntax: istream& operator>> (istream& is, TYP& a); Unser Beispiel als Basis, wäre es doch vorteilhaft, wenn man nicht die einzelnen Teile einer Komplexen Zahl einzeln einlesen müsste, sondern beide auf einmal, mit einem cin. Dafür müssen wir zunächst unsere Klasse Komplex mit dem Standardkonstruktor und mit Settern versehen oder die Funktion operator>> als friend in unsere Klasse aufnehmen. class Komplex{ private: float r; float i; public: Komplex(){} Komplex(float rr, float ii):r(rr),i(ii){}; float getR(){ return this.r;} float getI(){ return this.i;} void setR(float r){ this.r = r;} void setI(float i){ this.i = i;} }; class Komplex{ private: float r; float i; public: Komplex(){} Komplex(float rr, float ii):r(rr),i(ii){}; float getR(){ return this.r;} float getI(){ return this.i;} friend istream& operator>> (istream&,Komplex); }; ODER:

Überladen von Operatoren istream& operator>> (istream &in, Komplex& a){ cout << „Realteil: “; is >> a.r; cout << endl; cout > a.i; return is; } int main(){ Komplex k(12,3.4); Komplex g(2,1.2); Komplex b = k + g; cout << b;//Ausgabe: i Komplex z; //leeres Objekt, neue Komplexe Zahl cin >> z; //Abfrage kommt und Benutzer muss die Werte eingeben } Mit friend istream& operator>> (istream &in, Komplex& a){ float r,i; cout << „Realteil: “; is >> r; cout << endl; cout > i; a.setR(r); a.setI(i); return is; } ohne friend

Überladen von Operatoren Ein weiteres Beispiel:class Auto{ pivate: string name; int kmstand; public: Auto(string nname):name(nname),kmstand(0){}; int get_kmstand(){ return this.kmstand;} void set_kmstand(int neu){ this.kmstand = neu;} string get_name(){ return this.name;} }; void operator+ (Auto a, int b){ a.set_kmstand(a.get_kmstand() + b); cout << a.get_name()<< „ ist „ << b << „ Kilometer gefahren“ << endl; } int main(){ Auto a(„BMW“); //Neues Auto a + 30; //da + überschrieben wurde hat es den Rückgabewert „void“ //a hat nun als kmstand den Wert 30 return 1; } Ausgabe: BMW ist 30 Kilometer gefahren

Überladen von Operatoren Weitere Beispiele siehe Skript!