I dyn. Erzeugung von Objekten mit new statt malloc. I Vergleich zu C. I Erzeugung von Arrays mittel new[] I Speichergröße muss nicht angegeben werden

Transkript

1 Pointer mit new I dyn. Erzeugung von Objekten mit new statt malloc C++ und Pointer I Schlüsselwort new I Schlüsselwort delete I Unterschied zu malloc und free 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[8]; I Vergleich zu C int* feld2 = malloc(8*sizeof(int)); I Speichergröße muss nicht angegeben werden Freigabe mit delete 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[8]; delete[] feld; I Vergleich zu C int* feld2 = malloc(8*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; Pointer auf Objekte 4 class Test 6 public: 7 Test() 8 {cout << "constructor" << endl;} 9 ~Test() 10 {cout << "destructor" << endl;} 11 void Hello() {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) 87 88

2 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 Referenzen I Beispielcode I Unterschied Referenz <-> Pointer I wann verwendet man was? 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 Was ist eine Referenz I Referenzen sind Aliasnamen I Erzeugung mittels (&) nicht verwechseln mit Adressoperator ähnlich zu (*) int &someref = someint; I Referenz verhält sich wie Zielobjekt 4 int main() 6 int intone; 7 int &reference = intone; 8 9 intone = 5; 10 cout << "intone: " << intone << endl; 11 cout << "reference: " << reference << endl; 1 reference = 7; 14 cout << "intone: " << intone << endl; 15 cout << "reference: " << reference << endl; 16 } I Ausgabe: intone: 5 reference: 5 intone: 7 reference: 7 Der Adressoperator bei Referenzen 4 int main() 6 int intone; 7 int &reference = intone; 8 9 intone = 5; 10 cout << "intone: " << intone << endl; 11 cout << "reference: " << reference << endl; 1 cout << "&intone: " << &intone << endl; 14 cout << "&reference: " << &reference << endl; 15 } I Ausgabe: intone: 5 reference: 5 &intone: 0x7fff5fbffa2c &reference: 0x7fff5fbffa2c I Adressen der beiden Variablen sind identisch I Referenzen werden bei Erzeugung initialisiert dienen nur als Synonyme für ihr Ziele 91 92

3 Funktionsargumente als Zeiger übergeben 4 void swap(int *px, int*py) 6 int tmp; 7 tmp = *px; 8 *px = *py; 9 *py = tmp; 10 cout << "swap: " << *px << ", " << *py << endl; 11 } 1 int main() 14 { 15 int x=5, y=10; 16 swap(&x, &y); 17 cout << "main: " << x << ", " << y << endl; 18 } I Ausgabe: swap: 10, 5 main: 10, 5 I mühsam durch ständiges Dereferenzieren I Vorbereitungen für Aufruf nötig Funktionsargumente als Referenz übergeben 4 void swap(int &rx, int &ry) 6 int tmp; 7 tmp = rx; 8 rx = ry; 9 ry = tmp; 10 cout << "swap: " << rx << ", " << ry << endl; 11 } 1 int main() 14 { 15 int x=5, y=10; 16 swap(x, y); 17 cout << "main: " << x << ", " << y << endl; 18 } I Ausgabe: swap: 10, 5 main: 10, 5 I Syntax sehr viel direkter (leichter) I genauso leistungsfähig I keine Vorbereitungen in main nötig 9 94 Neuzuweisungen Übersicht Referenzen I Vorsicht beim Versuch einer Neuzuweisung 4 int main() 6 int x; 7 int &ref = x; 8 9 x = 5; 10 cout << "x: " << x << endl; 11 cout << "ref: " << ref << endl; 1 int y = 8; 14 ref = y; //not what you think cout << "x: " << x << endl; 17 cout << "y: " << y << endl; 18 cout << "ref: " << ref << endl; 19 } I Ausgabe: x: 5 ref: 5 x: 8 y: 8 ref: 8 I Referenz wirkt wirklich nur als Alias Neuzuweisung ist nicht möglich I Refenzen sind Synonyme für Variablen I sehr leichte Syntax I fast so leistungsfähig wie Zeiger I Initialisierung mit (&) nicht mit Adressoperator verwechseln I immer direkt initialisieren I nicht versuchen Referenzen erneut zuzuweisen I wie bei Zeigern auf Lebensdauer achten: 1 int& f() 2 { int x = 4711; 4 5 /*Achtung: Referenz auf lokale Variable*/ 6 return x; 7 } I Syntax kann Programmablauf verschleiern bei Pointern ist immer klar was passiert I keine vollsändige Alternative zu Pointern keine Mehrfachzuweisung Referenzen dürfen nicht 0 sein kein dynamischer Speicher möglich keine Felder von Referenzen möglich 95 96

4 Vererbung 2 I Polymorphie I virtuelle Methoden I abstrakte Klassen I Mehrfachvererbung Polymorphie I jedes Objekt der abgeleiteten Klasse ist auch ein Objekt der Basisklasse Vererbung impliziert immer ist-ein-beziehung I Jede Klasse definiert einen Datentyp Objekte können mehrere Typen haben abgeleitete Klassen haben mindestens zwei I In C++ kann der jeweils passende Typ verwendet werden Diese Eigenschaft nennt man Polymorphie (griech. Vielgestaltigkeit) in Code gegossen I Wir betrachten die Klasse Sortierverfahren: 1 class Sortierverfahren{ 2 protected: int N; //Anzahl 4 int* a; //zu sort. Zahlen 5 public: 6 Sortierverfahren(); 7 Sortierverfahren(int); 8 virtual ~Sortierverfahren(){delete[] a;}; 9 virtual void sort(){cout << "Hallo" << endl;}; 10 void ausgabe(); 11 }; I und die Methode sortme: 1 void sortme(sortierverfahren &s) 2 { s.sort(); 4 s.ausgabe(); 5 } I sortme übernimmt Referenz auf Sortierverfahren I virtuelle Methoden durch Schlüsselwort virtual ermöglichen späte Bindung (late binding) Einsprungadresse wird zur Laufzeit ermittelt dies geschieht intern mittels V-tables in Code gegossen - 2 I restliche Implementierung: 1 Sortierverfahren::Sortierverfahren(int n) 2 { N = n; 4 a = new int[n]; 5 for (int i = 0; i<n; i++) 6 a[i] = 1+rand() % 99; 7 } 8 9 void Sortierverfahren::ausgabe() 10 { 11 cout << "aktuelle Sortierung: " << endl; for (int i = 0; i<n; i++) 1 cout << a[i] << endl; 14 } I und abgeleitete Klasse BubbleSort: 1 class BubbleSort : public Sortierverfahren{ 2 public: BubbleSort(int N):Sortierverfahren(N){}; 4 void sort(); 5 }; 6 7 void BubbleSort::sort() 8 { 9 for (int i = N-1; i>=1; i--){ 10 for(int j = 0; j<i; j++) 11 {if (a[j] > a[j+1]) swap(a[j], a[j+1]);} } 1 }

5 in Code gegossen - Polymorphie- 2 I BubbleSort redefiniert die Methode sort I Nun ist BubbleSort auch ein Sortierverfahren I ) folgende Anweisung macht Sinn Sortierverfahren *mysort = new BubbleSort(10); I Bei Zeigern und Referenzen können alle Typen des jeweiligen Objektes verwendet werden I intern wird Zeiger auf Sortierverfahren gespeichert zunächst einmal kann nur auf diese Methoden und Felder zugegriffen werden I Frage: Was passiert bei Aufruf von mysort->sort()? I Antwort: genau das Richtige! durch Einsatz virtueller Methoden V-table wird angelegt zur Laufzeit wird entsprechende Funktion aufgerufen I Aufrufender Code: 1 void sortme(sortierverfahren& s) 2 { s.sort(); 4 s.ausgabe(); 5 } 6 7 int main() 8 { 9 BubbleSort mysort(10); 10 mysort.ausgabe(); 11 sortme(mysort); } I Ausgabe: aktuelle Sortierung: aktuelle Sortierung: (Zufallszahlen) I Methode sortme kennt nur s (Referenz auf Sortierverfahren) I Bei Aufruf von sort wird Einsprungstelle aus V-table gelesen I es wird tatsächlich sort von BubbleSort aufgerufen I Achtung: Klappt nur bei Zeigern und Referenzen Andere Aspekte der Polymorphie was es zu wissen gibt I virtuelle Methoden erlauben Polymorphie abgeleitetes Objekt verhält sich wie Basisobjekt I dies geschieht durch dynamische Bindung I Methoden als virtuell deklarieren wenn sie polymorph verwendet werden sollen I in diesem Fall auch virtueller Destruktor Objekt wird sonst evtl. nicht richtig bereinigt I Konstruktoren können nicht virtuell sein I in Java sind Methoden standardmäßig virtuell I in C++ explizit durch Benutzer I generell: Erzeugung von V-tables kostet Code wird dadurch langsamer virtual macht ohne Polymorphie keinen Sinn I polymorphes Verhalten ermöglicht Behandlung des abgeleiteten Objektes wie ein Basisobjekt Compiler betrachtet das Objekt als Basisobjekt (Slicing) Zugriff auf zusätzliche Methoden nicht möglich I Zugriff auch nicht sinnvoll I zumindest programmiertechnisch unsauber I Problem: was wenn man doch Zugriff braucht? I Lösung: dynamic cast fortbewegungsmittel *A = new car(); car *mycar = dynamic cast <car *> (A); mycar->fahren(); I gibt Nullpointer zurück wenn cast fehlschlägt I nur bei polymorph verwendeten Objekten möglich I es gibt auch noch andere casts: static cast const cast reinterpret cast

6 Beispiel abstrakte Datentypen I Die Methode sort von Sortierverfahren ist sinnlos bietet keinerlei Sortierung Objekte können in Wahrheit nicht sortieren I überhaupt sind Objekte dieser Klasse sinfrei von Sortierverfahren wird nur abgeleitet I das sollte sich auch im Code wiederspiegeln I abstrakte Klassen bieten genau das dienen als Schablone für abgeleitete Klassen können gemeinsame Funktionen implementieren müssen nicht alle Details implementieren I abstrakte Datentypen können nicht instanziiert werden! erleichtert Fehlersuche I abstrakte Klasse Sortierverfahren: 1 class Sortierverfahren{ 2 protected: int N; //Anzahl 4 int* a; //zu sort. Zahlen 5 public: 6 Sortierverfahren(); 7 Sortierverfahren(int); 8 virtual ~Sortierverfahren(){delete[] a;}; 9 virtual void sort() = 0; 10 void ausgabe(); 11 }; I abstrakte Methode in Zeile 9 I Abstraktion durch =0 nach virtueller Methode I AM müssen nicht implementiert werden I AM nennt man auch rein virtuell I durch eine AM wird die ganze Klasse abstrakt abstrakte Kl. können nicht instanziiert werden Beispiel I abgeleitete Klasse InsertionSort: 1 class InsertionSort : public Sortierverfahren{ 2 public: InsertionSort(int N):Sortierverfahren(N){}; 4 void sort(); 5 }; 6 7 void InsertionSort::sort() 8 { 9 int key,i; 10 for(int j=1;j<n;j++) 11 { key=a[j]; 1 i=j-1; 14 while(a[i]>key && i>=0) 1 16 a[i+1]=a[i]; 17 i--; 18 } 19 a[i+1]=key; 20 } 21 } I InsertionSort redefiniert die AM sort alle AM müssen redefiniert werden Beispiel 1 int main() 2 { BubbleSort mysort(10); 4 InsertionSort mysort2(10); 5 Sortierverfahren testsort(10); 6 mysort.ausgabe(); 7 mysort2.ausgabe(); 8 sortme(mysort); 9 sortme(mysort2); 10 } I Ausgabe: aktuelle Sortierung: aktuelle Sortierung: aktuelle Sortierung: aktuelle Sortierung: (Zufallszahlen) I Eigentlich gelogen: Fehler in Zeile 5 error: cannot declare variable testsort to be of abstract type Sortierverfahren

7 Mehrfachvererbung Übersicht - abstrakte Klassen I C++ erlaubt Vererbung mit multiplen Basisklassen I dienen als Schablone / Schnittstelle für Vererbung I können nicht instanziiert werden Fehlerfindung durch Compiler! I Was Sie tun sollten: Verwenden Sie AK für gemeinsame Funktionen (delegieren nach oben) jedoch nur wenn sie für alle Kinder relevant sind redefinieren Sie alle abstrakten Methoden definieren Sie alle Methoden abstrakt die zu redefinieren sind I Syntax: class Auto : public Wertgegenstand, public Fortbew{... } I Vertieft Konzept der Objektorientierung erhöht Wiederverwendbarkeit von Code I Problem: Mehrdeutigkeiten (nächste Folie) Diamantvererbung Diamantvererbung 2 I Es könnte eine gemeinsame Oberklasse geben I Klasse Matrix hat ein das Feld int n I beide abgeleiteten Klassen erben int n I SPD erbt von zwei Klassen SPD hat int n doppelt I Lösung 1: Zugriff mittels vollem Namen symmmat::n bzw. posdefmat::n I unschön, da Speicher dennoch doppelt unübersichtlich schlimmstenfalls sogar verschiedene Werte I Lösung 2: virtuelle Basisklassen class symmmat : virtual public matrix class posdefmat : virtual public matrix I führt zu Mehrdeutigkeit Felder und Methoden sind mehrfach vorhanden unklar worauf zugegriffen werden soll Speicherverschwendung schlimmstenfalls: Objekte inkonsistent I virtuelle Basisklasse wir nur einmal eingebunden I Literatur: Uneinigkeit ob Mehrfachvererbung sinnvoll I Konzept nicht möglich in Java, C# 111 1

8 konstante Funktionen I konstante Funktionen ändern die Klasse nicht sonstiges über Klassen I Deklaration mit nachgestelltem const nach Methodenname und vor Semikolon I zum Beispiel in car : void setage(int a); int getage() const; I set-methoden können natürlich nicht konstant sein I const I static I inline I Ziele: möglichst kontrollierter Zugriff Fehler schon zur Kompilierung abfangen richtigen Gebrauch der Klasse vorschreiben ) verhindert inkonsistente Objekte I guter Stil: möglichst viel als const deklarieren ) Fehler vor der Fertigstellung abfangen I ähnlich zu Zugriffskontrolle mit private, public ein Beispiel 2 #include <string> using namespace std; 4 5 class car 6 { 7 private: 8 int wert; 9 int age; 10 public: 11 int getage() const; void setage(int age) {this->age = age;}; 1 }; int car::getage() const 16 { 17 return age++; 18 } int main() 21 { 22 car TestCar; 2 TestCar.setAge(10); 24 cout << TestCar.getAge() << endl; 25 } I Fehler in Methode getage() increment of data-member car::age in read-only structure I Wichtig: const auch in Methodendefinition gehört zur Signatur warum so viel Kontrolle? I Fakt ist: alle Programmierer machen Fehler Code läuft beim ersten mal nie richtig I Großteil der Entwicklungszeit geht in Fehlersuche I Wie unterscheiden sich Profis von Anfängern? durch effizientere Fehlersuche I Compiler-Fehler sind leicht einzugrenzen es steht sogar die Zeilennummer dabei I Laufzeitfehler sind viel schwieriger zu finden Programm läuft, tut aber nicht das richtige manchmal fällt der Fehler ewig nicht auf ) sehr schlecht z.b. bei kommerzieller Software I ) möglichst viele Fehler durch Compiler abfangen I Methoden werden mit Verstand geschrieben I das sollte sich im Code wiederspiegeln gehören Daten strikt zu einer Klasse ) private Liest die Methode nur Daten aus ) const Zugriff kontrollieren mittels get und set

9 inline Funktionen I Traditionell in der OO: viele kleine Methoden man denke an get, set I Problem : Funktionsaufrufe sind nicht umsonst I Ausweg : inline Funktionen Code wird direkt eingefügt (ähnlich zu Makros) 4 inline int min(int a, int b) 6 return a<b? a : b; 7 } 8 9 int main() 10 { 11 cout << min(4, ) << endl; cout << min(, 4) << endl; 1 } I Umsetzung durch Compiler 4 int main() 6 cout << 4<? 4 : << endl; 7 cout << <4? : 4 << endl; 8 } inline Funktionen 2 I Deklaration durch Schlüsselwort inline I Compiler versucht Code direkt einzufügen inline-deklaration für Compiler nicht zwingend Compiler wägt ab und entscheidet nach Nutzen ) evtl. hat inline nicht gewünschten Effekt I Vorteile: Code kann schneller werden (kein Overhead) Optimierungspotential Berechnungen zur Kompilierzeit möglich I Nachteile: Code wird länger ausführbare Datei wird größer I Fazit: inline bei kurzen Funktionen die oft verwendet werden statische Daten I Daten die zu keinem konkreten Objekt gehören die Daten gehören zu der Klasse sie existieren nur einmal für die gesamte Klasse sie sind dennoch an die Klasse gebunden 4 class mitarbeiter{ 5 private: 6 string name; 7 string Abteilung; 8 public: 9 static int count; 10 mitarbeiter(){++count;}; 11 }; 1 int mitarbeiter::count = 0; int main(){ 16 mitarbeiter tom; 17 mitarbeiter bob; 18 cout << mitarbeiter::count << endl; 19 cout << tom.count << endl; 20 } I Ausgabe: 2 2 I Deklaration mit Schlüsselwort static I Initialisierung außerhalb von Methoden / Klassen I Zugriff über Klassenname oder Objekt (public) I globale Daten ) möglichst sparsam verwenden 119 statische Daten 2 I private static Daten können nur über Klassennamen verwendet werden I Zugriff nur über statische Funktionen I statische Funktionen können nur auf statische Daten zugreifen 4 class mitarbeiter{ 5 private: 6 string name; 7 string Abteilung; 8 static int count; 9 public: 10 static int getcount(){return count;}; 11 mitarbeiter(){++count;}; }; 1 14 int mitarbeiter::count = 0; int main(){ 17 mitarbeiter tom; 18 mitarbeiter bob; 19 cout << mitarbeiter::getcount() << endl; 20 } I Ausgabe: 2 0

10 noch ein Beispiel 4 enum Art {BRUCH, FLOAT}; 5 6 class ratio{ 7 private: 8 int z, n; 9 static Art ausgabeart; 10 public: 11 ratio(int a, int b){z=a; n = b;}; static int setzeausgabeart(art art); 1 void print(); 14 }; Art ratio::ausgabeart = BRUCH; int ratio::setzeausgabeart(art art) 19 {ausgabeart = art;} void ratio::print() 22 { 2 if (ausgabeart == BRUCH) 24 {cout << z << "/" << n << endl;} 25 else 26 {cout << double(z)/double(n) << endl;} 27 } int main(){ 0 ratio myratio1(,5); 1 ratio myratio2(1,7); 2 myratio1.print(); myratio2.print(); 4 ratio::setzeausgabeart(float); 5 myratio1.print(); 6 myratio2.print(); 7 } I Ausgabe: /5 1/ und weiter? I templates I Standardbibliothek I auto ptr I Headerfiles I exception handling I Softwaredesign / UML I Programmierprojekt 1 2