C++ und Pointer. I Schlüsselwort new I Schlüsselwort delete I Unterschied zu malloc und free

Transkript

1 C++ und Pointer I Schlüsselwort new I Schlüsselwort delete I Unterschied zu malloc und free 85

2 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 86

3 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[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[3]; delete t; I vielleicht sogar noch schlechter: int* t = new int; delete[] t; 87

4 Pointer auf Objekte 1 #include <iostream> 2 using namespace std; 3 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;} 13 }; int main() 16 { 17 Test* t1 = new Test(); 18 t1->hello(); 19 delete t1; 20 t1 = 0; 21 delete t1; 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

5 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

6 Referenzen I Beispielcode I Unterschied Referenz <-> Pointer I wann verwendet man was? 90

7 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 1 #include <iostream> 2 using namespace std; 3 4 int main() 5 { 6 int intone; 7 int &reference = intone; 8 9 intone = 5; 10 cout << "intone: " << intone << endl; 11 cout << "reference: " << reference << endl; reference = 7; 14 cout << "intone: " << intone << endl; 15 cout << "reference: " << reference << endl; 16 } I Ausgabe: intone: 5 reference: 5 intone: 7 reference: 7 91

8 Der Adressoperator bei Referenzen 1 #include <iostream> 2 using namespace std; 3 4 int main() 5 { 6 int intone; 7 int &reference = intone; 8 9 intone = 5; 10 cout << "intone: " << intone << endl; 11 cout << "reference: " << reference << endl; 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 92

9 Funktionsargumente als Zeiger übergeben 1 #include <iostream> 2 using namespace std; 3 4 void swap(int *px, int*py) 5 { 6 int tmp; 7 tmp = *px; 8 *px = *py; 9 *py = tmp; 10 cout << "swap: " << *px << ", " << *py << endl; 11 } 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 93

10 Funktionsargumente als Referenz übergeben 1 #include <iostream> 2 using namespace std; 3 4 void swap(int &rx, int &ry) 5 { 6 int tmp; 7 tmp = rx; 8 rx = ry; 9 ry = tmp; 10 cout << "swap: " << rx << ", " << ry << endl; 11 } 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 94

11 Neuzuweisungen I Vorsicht beim Versuch einer Neuzuweisung 1 #include <iostream> 2 using namespace std; 3 4 int main() 5 { 6 int x; 7 int &ref = x; 8 9 x = 5; 10 cout << "x: " << x << endl; 11 cout << "ref: " << ref << endl; 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 95

12 Übersicht Referenzen 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 { 3 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 96

13 Vererbung 2 I Polymorphie I virtuelle Methoden I abstrakte Klassen I Mehrfachvererbung 97

14 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) 98

15 in Code gegossen I Wir betrachten die Klasse Sortierverfahren: 1 class Sortierverfahren{ 2 protected: 3 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 { 3 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 99

16 in Code gegossen - 2 I restliche Implementierung: 1 Sortierverfahren::Sortierverfahren(int n) 2 { 3 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; 12 for (int i = 0; i<n; i++) 13 cout << a[i] << endl; 14 } I und abgeleitete Klasse BubbleSort: 1 class BubbleSort : public Sortierverfahren{ 2 public: 3 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]);} 12 } 13 } 100

17 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 101

18 in Code gegossen - 3 I Aufrufender Code: 1 void sortme(sortierverfahren& s) 2 { 3 s.sort(); 4 s.ausgabe(); 5 } 6 7 int main() 8 { 9 BubbleSort mysort(10); 10 mysort.ausgabe(); 11 sortme(mysort); 12 } 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 102

19 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 103

20 Andere Aspekte der Polymorphie 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 104

21 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 105

22 Beispiel I abstrakte Klasse Sortierverfahren: 1 class Sortierverfahren{ 2 protected: 3 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 106

23 Beispiel I abgeleitete Klasse InsertionSort: 1 class InsertionSort : public Sortierverfahren{ 2 public: 3 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 { 12 key=a[j]; 13 i=j-1; 14 while(a[i]>key && i>=0) 15 { 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 107

24 Beispiel 1 int main() 2 { 3 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 108

25 Übersicht - abstrakte Klassen 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 109

26 Mehrfachvererbung I C++ erlaubt Vererbung mit multiplen Basisklassen I Syntax: class Auto : public Wertgegenstand, public Fortbew{... } I Vertieft Konzept der Objektorientierung erhöht Wiederverwendbarkeit von Code I Problem: Mehrdeutigkeiten (nächste Folie) 110

27 Diamantvererbung I Es könnte eine gemeinsame Oberklasse geben I führt zu Mehrdeutigkeit Felder und Methoden sind mehrfach vorhanden unklar worauf zugegriffen werden soll Speicherverschwendung schlimmstenfalls: Objekte inkonsistent 111

28 Diamantvererbung 2 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 virtuelle Basisklasse wir nur einmal eingebunden I Literatur: Uneinigkeit ob Mehrfachvererbung sinnvoll I Konzept nicht möglich in Java, C# 112

29 sonstiges über Klassen I const I static I inline 113

30 konstante Funktionen I konstante Funktionen ändern die Klasse nicht 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 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 114

31 ein Beispiel 1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 class car 6 { 7 private: 8 int wert; 9 int age; 10 public: 11 int getage() const; 12 void setage(int age) {this->age = age;}; 13 }; int car::getage() const 16 { 17 return age++; 18 } int main() 21 { 22 car TestCar; 23 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 115

32 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 116

33 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) 1 #include <iostream> 2 using namespace std; 3 4 inline int min(int a, int b) 5 { 6 return a<b? a : b; 7 } 8 9 int main() 10 { 11 cout << min(4, 3) << endl; 12 cout << min(3, 4) << endl; 13 } I Umsetzung durch Compiler 1 #include <iostream> 2 using namespace std; 3 4 int main() 5 { 6 cout << 4<3? 4 : 3 << endl; 7 cout << 3<4? 3 : 4 << endl; 8 } 117

34 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 118

35 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 1 #include <iostream> 2 using namespace std; 3 4 class mitarbeiter{ 5 private: 6 string name; 7 string Abteilung; 8 public: 9 static int count; 10 mitarbeiter(){++count;}; 11 }; 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

36 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 1 #include <iostream> 2 using namespace std; 3 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;}; 12 }; int mitarbeiter::count = 0; int main(){ 17 mitarbeiter tom; 18 mitarbeiter bob; 19 cout << mitarbeiter::getcount() << endl; 20 } I Ausgabe: 2 120

37 noch ein Beispiel 1 #include <iostream> 2 using namespace std; 3 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;}; 12 static int setzeausgabeart(art art); 13 void print(); 14 }; Art ratio::ausgabeart = BRUCH; int ratio::setzeausgabeart(art art) 19 {ausgabeart = art;} void ratio::print() 22 { 23 if (ausgabeart == BRUCH) 24 {cout << z << "/" << n << endl;} 25 else 26 {cout << double(z)/double(n) << endl;} 27 } int main(){ 30 ratio myratio1(3,5); 31 ratio myratio2(1,7); 32 myratio1.print(); 33 myratio2.print(); 34 ratio::setzeausgabeart(float); 35 myratio1.print(); 36 myratio2.print(); 37 } I Ausgabe: 3/5 1/

38 und weiter? I templates I Standardbibliothek I auto ptr I Headerfiles I exception handling I Softwaredesign / UML I Programmierprojekt 122