I Operatoren selbst können überladen werden. I Methode add funktioniert auch. I Überladen sollte nur dafür verwendet werden

Transkript

1 Überladen von Operatoren 4 class Complex 5 { 6 private: 7 double vreal; 8 double vimag; 9 public: 10 Complex(double r, double i); 11 double getreal(){return vreal;}; 12 double getimag(){return vimag;}; 1 void setreal(double r){vreal = r;}; 14 void setimag(double i){vimag = i;}; 15 void print(); 16 }; Complex::Complex(double r, double i) 19 { 20 vreal = r; 21 vimag = i; 22 } 2 24 void Complex::print() 25 { 26 cout << getreal() << " + " << getimag() 27 << "i" << endl; 28 } 29 0 int main() 1 { 2 Complex mycomplex(, 5); mycomplex.print(); 4 } I Ausgabe: + 5i 60 Überladen von Operatoren 2 4 class Complex 5 { 6 /* private data */ 7 public: 8 Complex(double r = 0, double i = 0); 9 Complex add(complex rhs); /* remaining public data */ 12 }; 1 14 /* constructor and print definition */ Complex Complex::add(Complex rhs) 17 { 18 double rtmp = getreal() + rhs.getreal(); 19 double itmp = getimag() + rhs.getimag(); 20 return Complex(rTmp, itmp); 21 } 22 2 int main() 24 { 25 Complex mycomplex(, 5), mycomplex2(2, 7); 26 Complex mycomplex; 27 mycomplex = mycomplex.add(mycomplex2); 28 mycomplex.print(); 29 mycomplex2.print(); 0 mycomplex.print(); 1 } I Ausgabe: + 5i 2 + 7i i 61 Überladen von Operatoren 4 class Complex 5 { 6 /* private data */ 7 public: 8 Complex(double r = 0, double i = 0); 9 Complex operator+(complex rhs); /* remaining public data */ 12 }; 1 14 /* constructor and print definition */ Complex Complex::operator+(Complex rhs) 17 { 18 double rtmp = getreal() + rhs.getreal(); 19 double itmp = getimag() + rhs.getimag(); 20 return Complex(rTmp, itmp); 21 } 22 2 int main() 24 { 25 Complex mycomplex(, 5), mycomplex2(2, 7); 26 Complex mycomplex; 27 mycomplex = mycomplex + mycomplex2; 28 mycomplex.print(); 29 mycomplex2.print(); 0 mycomplex.print(); 1 } I Ausgabe: + 5i 2 + 7i i 62 Überladen von Operatoren 4 I Operatoren selbst können überladen werden mittels Schlüsselwort operator wie im Beispiel operator+ I Methode add funktioniert auch ist aber viel mühsamer in der Verwendung I vgl. Syntax: mycomplex = mycomplex.add(mycomplex2); mycomplex = mycomplex + mycomplex2; I interne Auswertung: mycomplex = mycomplex.operator+(mycomplex2); I Verwendung wird übersichtlicher Programm wird lesbarer I Überladen sollte nur dafür verwendet werden (+) mit(-) zu überladen nicht ratsam I Operatoren von Standardtypen können nicht überladen werden (z.b. int) I Zusätzliche Operatoren können hier auch nicht definiert werden 6

2 Überladen von typecasts was kann überladen werden + - * / & ˆ & ~! = < > += -= *= /= %= ˆ= &= = »= «= ==!= <= >= && ++ ->*, -> [] () new new[] delete delete[] I unäre und binäre Operatoren I unterscheide zwischen Postfix und Präfix leicht unterschiedliche Syntax I operator kann natürlich auch überladen werden gemischte Arithmetik möglich z.b. complex + real 1 class Complex 2 { /* private data */ 4 public: 5 Complex(int r){vreal = r; vimag = 0;}; 6 operator int(); 7 /* remaining public data */ 8 }; 9 10 Complex::operator int() 11 { 12 return int(vreal); 1 } int main() 16 { 17 Complex mycomplex(, 5), mycomplex2(2, 7); 18 int x = 1; 19 mycomplex2.print(); 20 mycomplex2 = x; 21 mycomplex2.print(); 22 cout << x << endl; 2 x = mycomplex; 24 cout << x << endl; 25 } I Ausgabe: 2 + 7i 1 + 0i 1 I typecast in nativen Datentyp mittels operator type I andere Richtung mittels Konstruktor Anmerkung strings I rückblickend: string ist eine Klasse mit vielen Methoden string überlädt Operatoren I für genauere Informationen API checken I Links: Klassendiagramm in UML I Unified Modeling Language I Modelierungssprache Softwaredesign zum Vererbung I was ist Vererbung? I geerbte Felder und Methoden I Methoden redefinieren I Aufruf von Basismethoden 66 67

3 Was ist Vererbung Was ist Vererbung 2 I im Alltag klassifizieren wir Objekte I wir teilen unsere Umgebung in Kategorien ein ein Auto ist ein Fortbewegungsmittel ein Hund ist ein Säugetier eine SPD-Matrix ist immer noch eine Matrix I alle Säugetiere können sich bewegen und atmen Hunde haben zusätzlich spezielle Eigenschaften... bellen, mit dem Schwanz wedeln... I Die Kategorien lassen sich weiter unterteilen Ferrari und Porsche beschreiben spezielle Autos I ganze Hierarchien entstehen Unterkategorien sind jeweils Erweiterungen Eigenschaften der Basiskategorie haben alle ) ist-ein-beziehung I C++ stellt Kategorien durch Klassen dar I spezielle werden von allgemeineren abgeleitet I diesen Vorgang nennt man Vererbung Was ist Vererbung Die Syntax der Vererbung I Vererbung in C++ bildet Wirklichkeit ab Spezialisierung durch zusätzliche Methoden allgemeine Methoden sind direkt verfügbar Fähigkeit bewegen muss bei Auto nicht separat implementiert werden I Syntax: ) das wurde von Fortbewegungsmittel geerbt class Car : public Fortbewegungsmittel I Ableitung erfolgt durch (:) I auto erbt alle Methoden und Felder von fortbewegungsmittel auto ist eine abgeleitete Klasse fortbewegungsmittel ist die Basisklasse I Alle Matrizen haben Einträge I reguläre Matrizen sind invertierbar I für SPD bietet sich zusätzlich Cholesky an

4 Ein Beispiel - ctn d Ein Beispiel 2 #include <string.h> using namespace std; 4 5 class Fortbewegungsmittel 6 { 7 protected: 8 double speed; 9 public: 10 Fortbewegungsmittel(){}; 11 ~Fortbewegungsmittel(){}; 12 Fortbewegungsmittel(double s){speed = s;}; 1 double getspeed(){return speed;}; 14 void setspeed(double s){speed = s;}; 15 void move(); 16 }; class Car : public Fortbewegungsmittel 19 { 20 private: 21 string color; 22 public: 2 Car(){}; 24 void fahren(); 25 string getcolor(){return color;}; 26 void setcolor(string c){color = c;}; 27 }; 1 /* class definitions */ 2 void Fortbewegungsmittel::print() 4 { 5 cout << "Geschwindigkeit: " << 6 getspeed() << endl; 7 } 8 9 void Fortbewegungsmittel::move() 10 { 11 cout << "Ich habe mich bewegt" << endl; 12 } 1 14 void Car::fahren() 15 { 16 cout << "Ich bin gefahren" << endl; 17 } int main() 20 { 21 Fortbewegungsmittel fahrrad(10); 22 Car mycar; 2 mycar.setspeed(50); 24 mycar.setcolor("rot"); 25 fahrrad.move(); 26 mycar.fahren(); 27 mycar.move(); 28 } I Ausgabe:Ich habe mich bewegt Ich bin gefahren Ich habe mich bewegt 72 7 Das Schlüsselwort protected I Problem: private Daten sind bei abgeleiteten Klassen nicht verfürbar Deklaration als public nicht sinnvoll I Lösung: protected I Daten sind für alle abgeleiteten Klassen sichtbar für alle anderen jedoch wie private 1 class Basis 2 { private: 4 int privat; 5 protected: 6 int protect; 7 public: 8 int publik; 9 }; class Abgelitten : public Basis 12 { 1 void zugriff() 14 { 15 a = privat; // Das gibt Ärger! 16 a = protect; // Das funktioniert. 17 a = publik; // Das funktioniert sowieso. 18 } 19 }; int main(){ 22 Basis myvar; 2 int a; 24 a = myvar.privat; // Das läuft nicht. 25 a = myvar.protect; // Das auch nicht. 26 a = myvar.publik; // Das funktioniert. 27 } 74 Konstruktoren der Basisklasse aufrufen I Vererbung bedeutet eine ist-ein-beziehung Jedes Auto ist ein Fortbewegungsmittel I Das merkt man am Aufruf Zuerst wird der Konstruktor der Basisklasse aufgerufen Danach der Konstruktor der abgeleiteten Klasse Bei Destruktoren anders herum I Entsprechend stellen Konstruktoren oft Erweiterungen dar z.b. zusätzliche Felder werden initialisiert I daher: Basisklassenkonstruktor aufrufen 1 Car::Car(double s, string c): 2 Fortbewegungsmittel(s), color(c) 4 { 5 cout << "car-konstruktor" << endl; 6 } 75

5 Funktionen redefinieren 2/2 Funktionen redefinieren 1/2 I Funktionen können in der abgeleiteten Klasse komplett neu gestaltet (redefiniert) werden 1 void Fortbewegungsmittel::print() 2 { cout << "Geschwindigkeit: " << getspeed() 4 << endl; 5 } 6 7 void Car::print() 8 { 9 cout << "Geschwindigkeit: " << getspeed() 10 << ", Farbe: " << getcolor() << endl; 11 } I nicht verwechseln mit überladen mehrere Methoden mit unterschiedlicher Signatur I in jedem Fall wird immer die richtige Methode aufgerufen I Problem: Basismethoden werden verdeckt eine redefinierte Methode verdeckt alle Basismethoden 1 void Fortbewegungsmittel::print(); 2 void Fortbewegungsmittel::print(int s); void Fortbewegungsmittel::print(int s, double c); 4 5 void Car::print(); 6 7 /* Implementierung */ 8 9 int main() 10 { 11 Car mycar; 12 mycar.print(); // OK 1 mycar.print(10); // funktioniert nicht 14 } I kein Zugriff mehr auf überladene Basisfunktionen I Lösung: Basisfunktion manuell aufrufen vollständigen Namen verwenden mycar.fortbewegungsmittel::print(10); Ein Beispiel 2/ Ein Beispiel 1/ 4 class Punkt{ 5 protected: 6 int x; 7 int y; 8 public: 9 Punkt(int x, int y); 10 int getx(){return x;}; 11 int gety(){return y;}; 12 void bewegen(int x, int y); //überladen 1 void bewegen(int x); 14 void bewegen(); 15 void print(); 16 void center(); 17 }; class Kreis : public Punkt{ 20 private: 21 int radius; 22 public: 2 Kreis(int x, int y, int radius); 24 int getrad(){return radius;}; 25 void bewegen(int r); //redefiniert 26 void print(); 27 }; I unterscheide zwischen überladen und redefinieren 78 1 Punkt::Punkt(int x, int y){ 2 this->x = x; this->y = y;} 4 5 void Punkt::bewegen(int x, int y){ 6 this->x = this->x+x; 7 this->y = this->y+y;} 8 9 void Punkt::bewegen(int x){ 10 this->x = this->x+x;} void Punkt::bewegen(){ 1 this->x = this->x-; 14 this->y = this->y-4;} void Punkt::print(){ 17 cout << "X: " << getx() << ", Y: " 18 << gety() << endl;} void Punkt::center(){ 21 x=0; y=0;} 22 2 Kreis::Kreis(int x, int y, int radius): 24 Punkt(x,y) 25 { 26 this->radius = radius; 27 } void Kreis::bewegen(int r){ 0 x = x+radius+r;} 1 2 void Kreis::print(){ cout << "X: " << getx() << ", Y: " << 4 gety() << ", Radius: " << getrad() << endl;} 79

6 Ein Beispiel / 1 int main() 2 { Punkt P1(,7); 4 P1.print(); 5 P1.bewegen(1); 6 P1.print(); 7 8 Kreis K1(,7,12); 9 K1.print(); 10 K1.bewegen(); 11 K1.print(); 12 K1.Punkt::bewegen(,4); 1 K1.print(); 14 K1.center(); 15 K1.print(); 16 } I Ausgabe:X:, Y: 7 X: 16, Y: 7 X:, Y: 7, Radius: 12 X: 18, Y: 7, Radius: 12 X: 21, Y: 11, Radius: 12 X: 0, Y: 0, Radius: 12 I in UML: Vererbung mit Matrizen 1/ 2 #include <vector> using namespace std; 4 5 class Matrix{ 6 protected: 7 int m,n; //dimensions 8 vector<vector<double> > entries; 9 public: 10 int getm(){return m;}; 11 int getn(){return n;}; 12 void setm(int dim){m = dim;}; 1 void setn(int dim){n = dim;}; 14 double getentry(int i, int j){return entries[i][j];}; 15 void setentry(int i, int j, double entry); 16 Matrix(); 17 Matrix(int m, int n, int init); 18 }; class ComplexMatrix : public Matrix{ 21 private: 22 vector<vector<double> > imag; 2 public: 24 double getimagentry(int i, int j){return imag[i][j];}; 25 void setimagentry(int i, int j, double entry); 26 ComplexMatrix(); 27 ComplexMatrix(int m, int n, int init); 28 }; Vererbung mit Matrizen 2/ 1 /* class definitions*/ 2 void Matrix::setEntry(int i, int j, double entry){ 4 if (i >= m j >= n){ 5 cout << "Index exceeds matrix dimensions" << endl; 6 }else{ 7 entries[i][j] = entry; 8 } 9 } Matrix::Matrix(): 12 m(1), n(1), 1 entries(vector<vector<double> >(m, vector<double>(n, 0))){} Matrix::Matrix(int m, int n, int init): 16 m(m), n(n), 17 entries(vector<vector<double> >(m, vector<double>(n, init))) 18 {} void ComplexMatrix::setImagEntry(int i, int j, double entry){ 21 if (i>m j > n){ 22 cout << "Index exceeds matrix dimensions" << endl; 2 }else{ 24 imag[i][j] = entry; 25 } 26 } ComplexMatrix::ComplexMatrix(): 29 imag(vector<vector<double> >(m, vector<double>(n, 0))){} 0 1 ComplexMatrix::ComplexMatrix(int m, int n, int init): 2 Matrix(m,n,init), imag(vector<vector<double> >(m, vector<double>(n, init))) 4 {} Übersicht - Vererbung I Vererbung macht den Code leichter zu warten I Verebung erhöht die Wiederverwendbarkeit massiv I genaue Implementierung der Basisklasse unwichtig I abgeleitete Klasse erbt alle Methoden und Felder sofern der Zugriff dies erlaubt I neue Implementierung für geerbte Methoden möglich Methoden redefinieren I Achtung: verdeckt alle gleichnamigen Basismethoden (dies kann natürlich gewollt sein) Zugriff über vollen Funktionsnamen I Fazit: verwende Vererbung immer wenn (sinnvoll) möglich verwende Code wieder wenn möglich senkt die Fehlerquote erleichtert spätere Änderungen 82 8

7 One more thing I es muss nicht immer public vererbt werden Basisklasse abgeleitete Klasse public protected private public public protected private protected protected protected private private hidden hidden hidden C++ und Pointer I Schlüsselwort new I Schlüsselwort delete I Unterschied zu malloc und free I Sichtbarkeit ändert sich durch Art der Vererbung Zugriff kann nur verschärft werden andere außer public machen selten Sinn Freigabe mit delete Pointer mit new I dyn. Erzeugung von Objekten mit new statt malloc int* i1 = new int; *i1 = 25; I Vergleich zu C int* i2 = malloc(sizeof(int)); *i1 = 25; I Erzeugung von Arrays mittel new[] int* feld = new int[128]; I Vergleich zu C int* feld2 = malloc(128*sizeof(int)); I Speichergröße muss nicht angegeben werden I Freigeben von Objekten mit delete statt free int* i1 = new int; delete i1; I Vergleich zu C int* i2 = malloc(sizeof(int)); free(i2); I Freigabe von Arrays mittel delete[] int* feld = new int[128]; delete[] feld; I Vergleich zu C int* feld2 = malloc(128*sizeof(int)); free(feld2); I nicht verwechseln: new, new[], delete, delete[] I schlecht: int* t = new int[]; delete t; I vielleicht sogar noch schlechter: int* t = new int; delete[] t; 86 87

8 Pointer auf Objekte 4 class Test 5 { 6 public: 7 Test() 8 {cout << "constructor" << endl;} 9 ~Test() 10 {cout << "destructor" << endl;} 11 void Hello() 12 {cout << "Hello World!" << endl;} 1 }; int main() 16 { 17 Test* t1 = new Test(); 18 t1->hello(); 19 delete t1; 20 t1 = 0; 21 delete t1; 22 2 Test* t2 = (Test*) malloc(sizeof(test)); 24 t2->hello(); 25 free(t2); 26 } I Ausgabe: constructor Hello World! destructor Hello World! I Zeiger nach delete auf 0 setzen (Z. 20) 88 Zusammenfassung I new legt Speicher an und ruft Konstruktor auf Konstruktor kann sogar ausgewählt werden Test* t1 = new Test(x,y,z); new[] ruft immer den Standardkonstruktor auf I Rückgabewert ist der richtige Zeiger I Speichergröße muss nicht angegeben werden I malloc legt nur Speicher an keine Initialisierung durch malloc Konstruktor kann nicht mehr aufgerufen werden I Speicher in Bytes muss angegeben werden I Rückgabewert ist immer void* explizites type-cast notwendig (bei nativen Typen optional) I delete löscht Speicher und ruft Destruktor auf I free gibt nur Speicher frei Destruktor kann nicht mehr aufgerufen werden I Fazit: Verwende new, delete mit C++ I Verwende malloc, free mit C I niemals die beiden vermischen z.b. new mit free freigeben I es gibt keine Alternative zu realloc z.b. vector verwenden 89