OOP und Angewandte Mathematik. Eine Einführung in die Anwendung objektorientierter Konzepte in der angewandten Mathematik

Transkript

1 Eine Einführung in die Anwendung objektorientierter Konzepte in der angewandten Mathematik WS 2011/12

2 Inhalt Templates Nochmal zusammengefasst Die Basis der OOP- Zusammengefasst 2

3 Templates Programmiersprachen sollten elegante Mechanismen besitzen, um Redundanz beim Programmieren vermeiden zu können. Angenommen, wir wollen Listen-, Array, oder Matrizen-Klassen implementieren, die verschiedene Datentypen als Inhalt aufnehmen können(z.b. int, double, bool, usw ). Alle Operationen bleiben gleich: true false true true true true false true false In C++ wird dieses Konzept Template genannt. Eine andere Bezeichnung (z.b. in Java 1.5) ist Generic. 3

4 Templates Motivation: Eine Klasse erstellen für verschiedene Datentypen Datenrepräsentation: Matrix, Stacks, Listen, Bäume... Code für einen Datentyp sollte für kompatible Typen wieder verwendbar sein. C++ bietet die Möglichkeit, mit Hilfe von Templates (Schablonen, Vorlagen) eine parametrisierte Familie verwandter Funktionen oder Klasse zu definieren Funktions-Templates legen die Anweisung einer Funktion fest, wobei statt eines konkreten Typs ein Parameter T gesetzt wird Klassen-Templates legen die Definition einer Klasse fest, wobei statt eines Typs ein Parameter T eingesetzt wird. Vorteile Ein Template muss nur einmal codiert werden. Einzelne Klassen oder Funktionen werden automatisch erzeugt. Einheitliche Lösung für gleichartige Probleme, wobei man unabhängige Bestandteile frühzeitig testen kann 4

5 Templates Funktions-Templates Beispiel: swap()-funktion Verhalten ist für jeden Typ gleich (elementar und andere) Ineffizient: schreibe für jeden Typ eine eigene überladene Funktion Lösung: definiere i eine Schablone für die Funktion swap() für Typ <int> swap() für beliebigen Typ <T> void swap (int& a, int& b) { int tmp = a; a = b; b = tmp; template <class T> void swap (T& a, T& b) { T tmp = a; a = b; b = tmp; 5

6 Templates Die template <...> Zeile sagt dem Compiler: die folgende Deklaration o. Definition ist als Schablone zu verwenden. Ein Template erwartet als Argumente Platzhalter für Typen: Template-Parameter template <class T> void swap (T& a, T& b) { T tmp = a; a = b; b = tmp; Die Platzhalter innerhalb des Template werden später (noch vor der Übersetzung in Maschinensprache) durch spezifische Typen ersetzt 6

7 Templates Templates sollen den Aufwand für den Entwickler reduzieren: Templates werden vom Kompiler nach Bedarf in eine normale Funktion/Klasse gewandelt. Wird swap für 2 int-werte verwendet, so wird eine weitere Funktion erzeugt. Wird swap für 2 Auto-Werte verwendet, so wird eine weitere Funktion erzeugt. Beim Kompilieren findet auch die Typprüfung statt. Syntax für explizite Spezialisierung double d1 = 4.0, d2 = 2.0; swap<double>(d1, d2); Explizit bedeutet: der Programmierer spezifiziert ausdrücklich, mit welchem Typ die Templateparameter zu ersetzen sind. 7

8 Templates Implizite Spezialisierung double d1 = 4.0, d2 = 2.0; //Alles klar: T = double swap(d1, d2); double d1 = 4.0; float f1 = 10.0f; swap(d1, f1); Das geht nicht! Compiler meldet: no matching function for call to swap(double&, float&) Entweder swap<double>(d1, f1); Implizite Typkonvertierung von <f1> Oder swap(d1, double(f1)); Explizite Typkonvertierung von <f1> 8

9 Templates In vielen Anwendungen ist es nicht nur notwendig eine Funktion, sondern eine ganze Klasse mit einem Typ zu parametrisieren. Z.B.: Implementierung von elementaren Datenstrukturen wie Stack, Queue, binäre Suchbäume,usw. Stack Beispiel template <class T> class Stack { private: T* inhalt; // Datenbereich des Stacks int index, size; // Aktueller Index, Grösse des Stacks public: Stack(int s): index(-1), size(s) { // Constructor inhalt = new T[size]; // Stack als Array implementiert void push(t item) { // Ein Element auf den Stack "pushen" if (index < (size - 1)) { inhalt[++index] = item; T top() const { // Ein Element vom Stack lesen if (index >= 0) {return inhalt[index]; void pop() { // Ein Element auf dem Stack löschen if (index >= 0) {--index; ; 9

10 Templates Gebrauch der Template-Klasse Stack int main() { Stack<int> intstack(100); Stack<double> doublestack(250); Stack<rect> rectstack(50); intstack.push(7); doublestack.push(3.14); rectstack.push(rect(2,5)); // Stack für 100 int // Stack für 250 double // Stack für 50 rect Bei der Allozierung eines Stacks muss explizit der Typ angegeben werden(<int>, <rect>,...) Auch hier gilt: die entsprechende ec e Klasse wird vom Compiler bei Bedarf aus der Template-Klasse generiert. 10

11 Templates Nochmals die Template-Klasse Stack, diesmal aber mit Trennung von Deklaration und Definition: Definition: stack.cpp Header-Datei: stack.h template <class T> class Stack { private: T* inhalt; int index; int size; public: Stack(int s); void push(type item); T top() const; void pop(); ; #include "stack.h" using namespace std; // Achtung: nicht Stack::Stack(int s)! template <class T> Stack<T>::Stack(int s):index(-1),size(s) size(s) { inhalt = new T[size]; template <class T> void Stack<T>::push(T item) { if(index<size) {inhalt[++index]=item; template <class T> T Stack<T>::top() const { if (index>=0) {return inhalt[index]; template <class T> void Stack<Type>::pop() { if (index >= 0) {index--; 11

12 Templates Gebrauch!!! #include "stack.cpp" " using namespace std; int main() { Stack<int> intstack(100); Stack<double> doublestack(250); intstack.push(7); doublestack.push(3.14); Man beachte: stack.cpp, nicht stack.h!!! Bei Templates muss die komplette Implementierung eingebunden werden, weil der Compiler die Klasse bei Bedarf erzeugt eugt (Spezifikation allein reicht also nicht) Dies gilt auch für Template Funktionen; Die Funktionsdeklaration allein reicht nicht. 12

13 Templates Die Angabe des Datentyps beim Gebrauch eines Templates bestimmt, wofür eine Instanz des Templates gebraucht werden kann: Stack<Person> personstack(100); // Nur für Typ Person verwendbar Ausnahme: auch Subklassen von Person können auf diesem Stack abgelegt werden. Dabei werden die Objekte aber in Person konvertiert... wodurch die in Subklassen spezifizierte Funktionalität (und damit auch Polymorphismus) verloren geht. Besser: man verwendet einen Zeiger auf die Basisklasse: Stack<Person*> personstack(100); // Für alle verwendbar Vorteile: Polymorphismus funktioniert; Subklassen von Person können auf dem Stack abgelegt werden, ohne deren zusätzliche Information zu verlieren. 13

14 Templates Templates von Templates: Templates können als Parameter für andere Templates dienen: complex<float> c1, c2; swap<complex<float> >(c1, c2); complex<t> ist eine Klasse der C++ Standard Bibl. für Komplexe Zahlen (#include <complex>) Achtung: Bei geschachtelten Templates muss man aufeinander folgende > durch Leerzeichen trennen, da sie sonst als shift-operator missinterpretiert werden. 14

15 Templates Ein Template existiert nicht als Typ oder Objekt. Erst bei Instanziierung eines Template entsteht eine neuer Typ (Funktion/Klasse) bei dem die Template-Parameter durch konkrete Typen ersetzt wurden. Ohne Templates: werden Interface und Implementierung in separaten Dateien untergebracht (.h,.cpp) stellt der Linker die Verbindung zwischen dem Aufruf einer deklarierten Methode und dem zusätzlichen Maschinen-Code her. Mit Templates: wird Code erst bei Bedarf generiert. Bedarf heißt, z.b. durch Bindung an spezifische Template-Parameter kann nur der vom Template generierte Code übersetzt und gelinkt werden. 15

16 Klassen und Strukturen in C++ Die Basis der OOP- Zusammengefasst C++ erlaubt unter anderen die Deklaration von Klassen und Strukturen zur Strukturierung eines OOP-Programms. Klassen und Strukturen unterscheiden sich in C++ prinzipiell kaum. In beiden können Sie Eigenschaften und Methoden unterbringen. Klassen werden mit dem Schlüsselwort class deklariert, Strukturen mit struct. Alle Datenfelder in einer Struktur sind öffentlich. Klassen ermöglichen dagegen, dass Datenfelder privat oder geschützt (protected) deklariert werden. Strukturen ermöglichen somit nicht das wichtige Konzept der Kapselung. class person{ string Name; // private string Nachname //private public: void laufen(){ //public ; struct person{ string Name; // public string Nachname //public void laufen(){ //public ; 16

17 Klassen und Strukturen in C++ Strukturen können nur wie einfache Klassen behandelt werden, damit die Umsetzung von C-Quellcode nach C++ vereinfacht wird. Da die Strukturen die wichtige Kapselung nicht unterstützen, sollten Sie stattdessen immer Klassen einsetzen. In dieser Vorlesung wird class immer benutzt! 17

18 Die Strukturierung einer Anwendung Größere Programme erfordern eine Strukturierung des Quellcodes. Die Basis der Strukturierung ist in C++ eine Klasse. Über Klassen erreichen Sie, dass Sie Programmcode wiederverwenden können und dass Sie Ihr Programm so strukturieren, dass die Fehlersuche und die Wartung erheblich erleichtert werden. Wenn Sie eine Klasse entwickeln, können Sie entscheiden, ob Sie eine echte Klasse (mit normalen Eigenschaften und Methoden) programmieren, aus der Sie später Instanzen erzeugen, oder ob Sie eine Klasse mit statischen Methoden und Eigenschaften erzeugen wollen. Statische Methoden und Eigenschaften (Klassenmethoden, Klasseneigenschaften) können Sie auch ohne eine e Instanz der Klasse aufrufen. ufe Echte Klassen arbeiten echt objektorientiert, Klassen mit statischen Methoden und Eigenschaften simulieren (u. a.) die Module der strukturierten Programmierung. 18

19 Einfache Klassen und deren Anwendung Grundlagen zur Programmierung von Klassen In einer C++-Datei (mit der Endung.cpp oder.cc)) können Sie eine oder mehrere Klassen implementieren. Sie können Klassen komplett in der cpp-datei unterbringen und auf eine Headerdatei verzichten oder In h-datei und cpp-datei trennen. Die h-datei (Headerdatei) enthält die Deklaration der Klasse, die cpp-datei enthält die Implementierung der Methoden der Klasse. In einer cpp-datei können Sie eine oder mehrere Klassen unterbringen. In der Praxis werden Klassen oft in separaten Dateien deklariert, um diese einfach in anderen Programmen wiederverwenden d zu können. Diese Trennung macht auch dann Sinn, wenn Sie Ihre Klassen in Bibliotheken (mit der Endung.lib) kompilieren und diese Bibliotheken für die eigene Verwendung in einem separaten Ordner speichern. 19

20 Einfache Klassen und deren Anwendung Objekte statisch erzeugen Statisch erzeugen Sie ein Objekt, indem Sie eine Objektvariable wie eine einfache Variable deklarieren: Kreis k; // statische Erzeugung Statisch bedeutet hier, dass C++ das Objekt auf dem Stack speichert. Der Stack ist ein Speicherbereich, den alle Programme besitzen und auf dem u. A. alle lokalen Variablen einer Funktion oder Methode gespeichert werden. Da der Stack nach der Ausführung der Funktion/Methode wieder automatisch bereinigt wird, werden statische Objekte also automatisch zerstört, wenn die Funktion bzw. Methode beendet ist. Ein Problem bei statischen ti Objekten ist, das Objekt könnte zu groß sein, und man muss bei der Entwicklung immer beachten wie viele Objekt erzeugt werden müssen. 20

21 Einfache Klassen und deren Anwendung Objekte dynamisch erzeugen Für die dynamische Erzeugung g von Objekten deklarieren Sie die Objektvariable als Zeiger: Kreis * k; // dynamische Erzeugung Dann erzeugen Sie das Objekt über den new-operator: Kreis = new Kreis Dynamisch erzeugte Objekte werden auf dem Heap angelegt. Der Heap ist ein Speicherbereich, der für globale Daten reserviert ist. Auf dem Heap werden außerdem alle Funktionen und Klassen einer Anwendung gespeichert. Die Größe des Heap ist nur durch den im System verfügbaren Speicher begrenzt. So kann Ihre Anwendung während des Programmablaufs (eben dynamisch) nahezu beliebig viele Objekte erzeugen. 21

22 Einfache Klassen und deren Anwendung Objekte dynamisch erzeugen Objekte, die dynamisch erzeugt wurden, können über eine Dereferenzierung des Zeigers angesprochen werden: (*k). Radius = 20 Durchgesetzt hat sich aber die Kurzschreibweise, die mit dem Operator -> arbeitet: k->radius = 20 Dynamisch erzeugt Objekte müssen Sie wie alle dynamisch reservierten Speicherbereiche über die delete-anweisung aus dem Speicher entfernen. delete k; Vergessen Sie dies, bleibt das Objekt im Speicher, so lange Ihre Anwendung läuft, und verbraucht unnötig Ressourcen. 22

23 Einfache Klassen und deren Anwendung Die Bedeutung des Stack Der Stack ist ein spezieller Speicherbereich, den jedes Programm besitzt und der wie ein Stapel arbeitet: Daten werden der Reihe nach auf dem Stapel abgelegt und können auch wieder, der Reihe nach, vom Stapel entfernt werden. (Last in first out-lifo) Der Stack wird vom Compiler automatisch über Funktionen angesprochen, die Daten auf dem Stapel ablegen, Daten vom Stapel auslesen und vom Stapel löschen. 23

24 Einfache Klassen und deren Anwendung Die Bedeutung des Stack : Beispiel int Add(int x, int y) { int result; result = x + y; return result; void main(void) { int i = Add(1, 2); cout << I; Beim Aufruf der Funktion Add, legt der Compiler die folgenden Daten auf dem Stack an: 1. einen Speicherbereich für den Rückgabewert der Funktion, 2. die Adresse, zu der das Programm nach der Ausführung zurückspringen muss, 3. die Argumente der Funktion, 4. und die lokalen Variablen der Funktion. 24

25 Einfache Klassen und deren Anwendung Wie werden Objekte gespeichert? Um zu verstehen wie z.b den Polymorphismus und virtuellen Methoden funktionieren, müssen Sie wissen wie, Objekte prinzipiell gespeichert werden. Eine Instanz einer Klasse besteht prinzipiell nur aus den Datenfeldern der Klasse (außer, wenn die Klasse Inline-Methoden beinhaltet, die innerhalb der Instanz gespeichert werden). Beispiel class Punkt { public: int x; int y; void set(int x, int y) { this->x = x; this->y = y; ; class Kreis { public: int Radius; int Farbe; double Umfang { return Radius * 2 * ; ; 25

26 Einfache Klassen und deren Anwendung Wie werden Objekte gespeichert? void main(void) { Kreis k1; Kreis k2; Punkt p1; k1.radius = 100; k1.farbe = 255; k2.radius = 200; k2.farbe = 1024; p1.set(10, 11); k1, k2 und p1 sind also Variablen, die auf die Adresse zeigen, an der die Eigenschaften des Objekts gespeichert sind. Dieses Vorgehen reduziert den Speicherbedarf von Objekten enorm. 26

27 Einfache Klassen und deren Anwendung Der this-zeiger Damit eine Methode, die ja normalerweise (wenn es keine Inline-Methode ist), die Eigenschaften der aufrufenden Instanz bearbeiten kann, übergibt der Compiler der Methode ein zusätzliches, unsichtbares Argument, den this->zeiger. double Umfang(Kreis *this) { return this->radius *2* ; Dieser Zeiger zeigt auf die Objektinstanz, von der aus der Aufruf erfolgt ist. Wenn Sie in einer Methode auf Eigenschaften oder Datenfelder des Objekts zugreifen oder andere Methoden aufrufen, stellt der Compiler diesen Zeiger implizit vor den Namen des verwendeten Klassenelements, falls dies noch nicht explizit geschehen ist und falls ein entsprechendes Klassenelement gefunden wird. Siehe nächste Folie... 27

28 Einfache Klassen und deren Anwendung Konkretes this-> Beispiel main: class Kreis { public: int Radius; int Farbe; double Umfang { return Rdi Radius * 2 * ; ; Kreis k1 // Statisch deklariert K1 als Objekt hat Radius und Farbe als Eigenschaften und kann Umfang (Methode)aufrufen Implizit sieht im kompilierten Programmcode demnach so aus, falls noch nicht so definiert ist double Umfang(Kreis *this) { return this->radius * 2 * ; K1 (ist Aufrufer) this ist der der zu eine gegebene Zeit eine Funktion Ausführt 28

29 OOP Nächste Woche... 29

30 Die Basis der OOP- Zusammengefasst Die Sichtbarkeit von Klassenelementen Daten schützen: Die Kapselung Die klassische Kapselung Bessere Kapselung mit Ausnahmen Konstruktoren und Destruktoren Konstruktoren Der Copy-Konstruktor Der Destruktor Assoziationen zwischen Objekten 30

31 Die Basis der OOP- Zusammengefasst Vererbung Warum Vererbung? Das Beispiel Die Grundlagen der Vererbung Die Neudefinition iti von Methoden Verwenden geerbter Elemente Die Sichtbarkeit bei der Vererbung Veröffentlichen von privaten und geschützten Elementen in abgeleiteten Klassen Vererbung von Konstruktoren und Destruktoren Polymorphismus und virtuelle Methoden public-, protected- und private-ableitung Mehrfachvererbung 31

32 OOP-Specials Abstrakte Klassen und Methoden Statische Klassenelemente Statische Eigenschaften (Klasseneigenschaften) Statische Methoden (Klassenmethoden) Verschachtelte Klassen Friends Operatoren für Klassen Schnittstellen 32