Beispiel 1/3. Abstrakte Datentypen. Beispiel 3/3. Beispiel 2/3. Abstrakte Klasse SortierVerfahren

Transkript

1 Beispiel 1/ Abstrakte Klasse SortierVerfahren Abstrakte Datentypen Die Methode sort von Sortierverfahren ist sinnlos bietet keinerlei Sortierung Objekte können in Wahrheit nicht sortieren Überhaupt sind Objekte dieser Klasse sinnfrei von Sortierverfahren wird nur abgeleitet Das sollte sich auch im Code wiederspiegeln Abstrakte Klassen bieten genau das dienen als Schablone für abgeleitete Klassen können gemeinsame Funktionen implementieren müssen nicht alle Details implementieren Abstrakte Datentypen können nicht instanziiert werden! erleichtert Fehlersuche 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 }; Abstrakte Methode in Zeile 9 Abstraktion durch =0 nach virtueller Methode Syntax: virtual rtype funname(varlist) = 0 rtype ist Typ d Rückgabewerts von Fkt funname varlist bezeichnet beliebige Inputparameter Virtuelle Methode wird durch nachgestelltes = 0 als abstrakt deklariert AM müssen nicht implementiert werden AM nennt man auch rein virtuell Durch eine AM wird die ganze Klasse abstrakt abstrakte Kl. können nicht instanziiert werden 29 0 Beispiel 2/ 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 int key,i; 9 for(int j=1;j<n;++j) { 10 key=a[j]; 11 i=j-1; 12 while(a[i]>key && i>=0) { 1 a[i+1]=a[i]; 14 i--; 15 } 16 a[i+1]=key; 17 } 18 } InsertionSort redefiniert die AM sort alle AM müssen redefiniert werden Beispiel / 1 int main() { 2 BubbleSort mysort(10); InsertionSort mysort2(10); 4 Sortierverfahren testsort(10); 5 mysort.ausgabe(); 6 mysort2.ausgabe(); 7 sortme(mysort); 8 sortme(mysort2); 9 } Ausgabe: aktuelle Sortierung: aktuelle Sortierung: aktuelle Sortierung: aktuelle Sortierung: (Zufallszahlen) Eigentlich gelogen: Fehler in Zeile 5 error: cannot declare variable testsort to be of abstract type SortierVerfahren 1 2

2 Mehrfachvererbung Übersicht - abstrakte Klassen C++ erlaubt Vererbung mit multiplen Basisklassen Dienen als Schablone / Schnittstelle für Vererbung Können nicht instanziiert werden Fehlerfindung durch Compiler! 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 Syntax: class Auto : public Wertgegenstand, public Fortbew{...} Vertieft Konzept der Objektorientierung erhöht Wiederverwendbarkeit von Code Problem: Mehrdeutigkeiten (nächste Folie) 4 Diamantvererbung 2/2 Diamantvererbung 1/2 Es könnte eine gemeinsame Oberklasse geben Klasse Matrix hat ein Feld int n beide abgeleiteten Klassen erben int n SPD erbt von zwei Klassen SPD hat int n doppelt Lösung 1: Zugriff mittels vollem Namen symmmat::n bzw. posdefmat::n Unschön, da Speicher dennoch doppelt unübersichtlich schlimmstenfalls sogar verschiedene Werte Lösung 2: virtuelle Basisklassen Führt zu Mehrdeutigkeit Felder und Methoden sind mehrfach vorhanden Unklar worauf zugegriffen werden soll Speicherverschwendung Schlimmstenfalls: Objekte inkonsistent class symmmat : virtual public matrix class posdefmat : virtual public matrix Virtuelle Basisklasse wird nur einmal eingebunden Literatur: Uneinigkeit ob Mehrfachvererbung sinnvoll sein kann Konzept nicht möglich in Java, C# 5 6

3 Generische Programmierung Templates Was sind Templates? Funktionentemplates Klassentemplates template Wieso Umstieg auf höhere Programmiersprache? Mehr Funktionalität (Wiederverwendbarkeit/Wartbarkeit) haben wir bei Vererbung ausgenutzt Ziele: möglichst wenig Code selbst schreiben Gemeinsamkeiten wiederverwenden nur Modifikationen implementieren Oftmals ähnlicher Code für verschiedene Dinge Vererbung bietet sich oft nicht an es liegt nicht immer Ist-Ein-Beziehung vor Idee: Code unabhängig vom Datentyp entwickeln Führt auf generische Programmierung 7 8 Beispiel: Maximum Aufgabe: Maximum berechnen / quadrieren 1 int max(int a, int b) { 2 if (a < b) return b; 4 else 5 return a; 6 } 7 8 double max(double a, double b) { 9 if (a < b) 10 return b; 11 else 12 return a; 1 } int sqr(int a) { 16 return a*a; 17 } double sqr(double a) { 20 return a*a; 21 } Gleicher Code für viele Probleme Vererbung bietet sich hier nicht an z.b. Quadrate von Matrizen Lösung: Templates Funktionstemplate 1/2 Funktionalität unabhängig vom Datentyp: 4 template <typename T> 5 T square(const T& t) { 6 return t*t; 7 } 8 9 int main() { 10 cout << square<double>(4.7) << endl; 11 cout << square(4.7) << endl; 12 } Ausgabe: t ist Platzhalter für Daten vom Typ T Für alle DT die Multiplikation * bereitstellen z.b. Quadrate von Matrizen Bei Aufruf DT in spitze Klammern (Z. 8) kann auch weggelassen werden (Z. 9) template <typename T> rtype funname(varlist) Einleitung durch Schlüsselwort template Templateparameter in spitzen Klammern allgemeiner Datentyp: typename alternative Syntax: class T ist Name des Parameters (beliebiger Name) rtype ist Typ des Rückgabewerts von funname Rückgabe u Eingabe können vom Typ T sein auch Referenz oder Pointer auf T möglich 9 40

4 Funktionstemplate 2/2 Klassentemplate 1/ Was passiert eigentlich bei folgendem Code? 4 template <typename T> 5 T square(const T& t) { 6 return t*t; 7 } 8 9 int main() { 10 int x = 2; 11 double y = 4.7; 12 cout << square(x) << endl; 1 cout << square(y) << endl; 14 } Compiler erkennt dass Fkt square einmal für Typ int und einmal für Typ double benötigt wird Compiler erzeugt ( programmiert ) und kompiliert anhand von dieser Information, zwei (!) Funktionen mit der Signatur double square(double) int square(int) D.h. Funktion square wird automatisch anhand des Templates (= Vorlage) generiert also nur für die Typen die wirklich benötigt Auch allgemeine Klassen möglich haben wir bereits verwendet (vector) Automatische Speicherverwaltung bei Pointern: 1 template <typename T> 2 class simple_ptr { public: 4 simple_ptr(t* ptr); 5 ~simple_ptr(); 6 T& operator*(); 7 T* operator->(); 8 private: 9 //Die Klasse soll nicht kopierbar sein. 10 simple_ptr(const simple_ptr&); 11 simple_ptr& operator=(const simple_ptr&); 12 1 T* m_ptr; 14 }; Idee: Speicher automatisch freigeben verhindert Speicherlecks Für Pointer von beliebigem Typ Das nennt man Smartpointer Um zu verhindern, dass Obj der Kl kopiert werden kann schreibt man Kopierkonstruktor und Zuweisungsoperator in den private Bereich Klassentemplate / Restliche Klassenmethoden Klassentemplate 2/ Implementierung von Klassenmethoden Beispiel: Konstruktor 1 template <typename T> 2 simple_ptr<t>::simple_ptr(t* ptr) : m_ptr(ptr) {} Syntax: voranstellen von template <typename T> Wichtig: <T> nach Klassenname (Methode für Klasse simple ptr<t>) (bei jeder Methode) tatsächliche Implementierung wie gehabt 1 template <typename T> 2 simple_ptr<t>::~simple_ptr() { if(m_ptr) 4 delete m_ptr; 5 m_ptr = NULL; 6 } 7 8 template <typename T> 9 T& simple_ptr<t>::operator*() { 10 return *m_ptr; 11 } 12 1 template <typename T> 14 T* simple_ptr<t>::operator->() { 15 return m_ptr; 16 } int main() { 19 simple_ptr<string> 20 some_stringptr(new string("hallo")); 21 cout << *some_stringptr << endl; 22 } Ausgabe: Hallo Destruktor gibt Speicher wieder frei (Garbage Collection) Operatoren * und -> überladen für Funktionalität von Pointer 4 44

5 Private Methoden Probleme bei Kopien von Smartpointern: 1 int main() { 2 simple_ptr<string> p(new string("blub")); p->size(); 4 { 5 simple_ptr<string> q = p; 6 q->size(); 7 // Destruktor von q wird aufgerufen 8 } 9 p->size(); 10 } Pointer wird kopiert (Z. 5) Speicher wird freigegeben (Z. 8) Problem: Speicher von p auch freigegeben const static inline Sonstiges über Klassen Hier: Zuweisung in (Z. 5) nicht möglich (Methode ist private) Sonst Lösung: Kopien zählen Speicher nur freigeben wenn kein Zugriff mehr (wird hier nicht vertieft) Schlüßelwort const 2/2 Schlüßelwort const 1/2 Bereits kennengelernt: Read-Only Referenzen const type& name Äquivalent zu type const& name Konstante (Read-Only) Methoden Deklaration mit nachgestelltem const nach Methodenname und vor Semikolon greifen nur lesend auf Members der Klasse zu const gehört zur Signatur der Methode Ziele: Möglichst kontrollierter Zugriff Fehler schon zur Kompilierung abfangen richtigen Gebrauch der Klasse vorschreiben verhindert inkonsistente Objekte Guter Stil: möglichst viel als const deklarieren Fehler vor der Fertigstellung abfangen ähnlich zu Zugriffskontrolle mit private, public 47 Man kann auch konstante Objekte definieren const type name = obj type gibt Datentyp an name ist Name des konstanten Obj Konst Obj muss bei Dekl. initialisiert werden Konst Obj ist nach Def nicht mehr veränderbar z.b. const double pi =.14159; definiert konstanten double Wert pi Anweisung pi = pi ; ist nicht möglich const mit Pointer ist auch möglich Hier ist auf unterschiedl Verwendungsweisen zu achten const type* name = adress Definiert einen Pointer auf konstantes Obj vom Typ type nur lesender Zugriff auf Obj mit Adresse adress Achtung: Man kann Pointer versetzen int a = 10, b = 5; const int* p = &a; p = &b type* const name = adress Def. konstanten Pointer name Pointer ist nicht mehr versetzbar Obj auf das gezeigt wird aber schon 48

6 Inline Funktionen Wiederholung Traditionell in der OO: viele kleine Methoden man denke an get, set Problem : Funktionsaufrufe sind nicht umsonst Ausweg : inline Funktionen Code wird direkt eingefügt (ähnlich zu Makros) 4 inline int sqr(int a) { 5 return a*a; 6 } 7 8 int main() { 9 cout << sqr() << endl; 10 cout << sqr(4) << endl; 11 } Umsetzung durch Compiler 4 int main() { 5 cout << * << endl; 6 cout << 4*4 << endl; 7 } Inline Funktionen 2 Deklaration durch Schlüsselwort inline 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 Vorteile: Code kann schneller werden (kein Overhead) Optimierungspotential Berechnungen zur Kompilierzeit möglich Nachteile: Code wird länger ausführbare Datei wird größer Fazit: inline bei kurzen Funktionen die oft verwendet werden Statische Daten 1/2 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 string name; 6 string Abteilung; 7 public: 8 static int count 9 mitarbeiter(){ ++count; } 10 }; int mitarbeiter::count = 0; 1 14 int main() { 15 mitarbeiter tom; 16 mitarbeiter bob; 17 cout << mitarbeiter::count << endl; 18 cout << tom.count << endl; 19 } Ausgabe: 2 2 Deklaration mit Schlüsselwort static Initialisierung außerhalb von Methoden / Klassen Zugriff über Klassenname oder Objekt (public) Statische Daten 2/2 private static Daten können nur über Klassennamen verwendet werden Zugriff nur über statische Funktionen statische Funktionen können nur auf statische Daten zugreifen 4 class mitarbeiter { 5 string name; 6 string Abteilung; 7 static int count; 8 public: 9 static int getcount(){return count;}; 10 mitarbeiter(){++count;}; 11 }; 12 1 int mitarbeiter::count = 0; int main() { 16 mitarbeiter tom; 17 mitarbeiter bob; 18 cout << mitarbeiter::getcount() << endl; 19 } Ausgabe: 2 globale Daten möglichst sparsam verwenden 51 52

7 Noch ein Beispiel 4 enum Art {BRUCH, FLOAT}; 5 6 class ratio{ 7 int z, n; 8 static Art ausgabeart; 9 public: 10 ratio(int a, int b){z=a; n = b;} 11 static int setzeausgabeart(art art); 12 void print(); 1 }; Art ratio::ausgabeart = BRUCH; int ratio::setzeausgabeart(art art) 18 {ausgabeart = art;} void ratio::print() { 21 if (ausgabeart == BRUCH) 22 cout << z << "/" << n << endl; 2 else 24 cout << double(z)/double(n) << endl; 25 } int main() { 28 ratio myratio1(,5), myratio2(1,7); 29 myratio1.print(); 0 myratio2.print(); 1 ratio::setzeausgabeart(float); 2 myratio1.print(); myratio2.print(); 4 } Ausgabe: /5 1/ Danke für Ihre Aufmerksamkeit 5 54