Programmierung und Angewandte Mathematik

Transkript

1 Programmierung und Angewandte Mathematik C++ /Scilab Programmierung und Einführung in das Konzept der objektorientierten Anwendungen zu wissenschaftlichen Rechnens SS 2012

2 OOP Specials Templates Fehler- und Ausnahmebehandlung Überladung von Operatoren UML (Klassendiagramme) Probe Klausur(30 Mins) 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 fl false true 2 a 7 c true true true oder auch 6, false true false c 0 2,3 b In C++ wird dieses Konzept Template genannt. Eine andere Bezeichnung (z.b. in Java 1.5) ist Generic. Diese können wir mit Template und Vererbung lösen! 3

4 Templates 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 t wird Klassen-Templates legen die Definition einer Klasse fest, wobei statt eines Typs ein Parameter T eingesetzt wird. template <class T> void swap (T& a, T& b) { T tmp = a; a = b; b = tmp; void swap (char & a, char & b) { char tmp = a; a = b; b = tmp; 4

5 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. 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 5

6 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 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; 6

7 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, class S, > void swap (T& a, T& b, S& x) { 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 7

8 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 it Spezialisierung i 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. 8

9 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); Entweder Das geht nicht! Compiler meldet: no matching function for call to swap(double&, float&) swap<double>(d1, f1); Oder Implizite Typkonvertierung von <f1> swap(d1, double(f1)); Explizite Typkonvertierung von <f1> 9

10 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) { if (index < (size - 1)) { inhalt[++index] = item; // Ein Element auf den Stack "pushen" 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; 10

11 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); h(314) 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 g werden(<int>, <rect>,,...) Auch hier gilt: die entsprechende Klasse wird vom Compiler bei Bedarf aus der Template- Klasse generiert. 11

12 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--; 12

13 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 (Spezifikation allein reicht also nicht) Dies gilt auch für Template Funktionen; Die Funktionsdeklaration allein reicht nicht. 13

14 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: Vorteile: Polymorphismus funktioniert; Subklassen von Person können auf dem Stack abgelegt Stack<Person*> werden, personstack(100); ohne deren zusätzliche // Für alle Information verwendbar zu verlieren. 14

15 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. 15

16 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. 16

17 Fehler in C/C++ Häufige Fehler: Syntaxfehler: Fehler im formalen Aufbau und Rechtschreibfehler führen zu Syntaxfehlern. Beispiele: 1) a = b + c // Semikolon vergessen cout << a << endl; 2) while(a!= b); // irrtümlich Semikolon hinter while-anweisung {. ; // (oder for oder if) 3) do{ while(a <= b) // Semikolon hinter do while vergessen 4) while(a = b) // Zweisungsoperator = statt Gleichheitsoperator // == verwendet 5) int auto, moped; Auto = moped / 7; // Variable auto groß geschrieben, in der // Deklaration aber klein 6) int summe, i, a[100]; for(i = 0; i <= 100; i++) // Indexbereich ueberschritten, letztes summe = summe + a[i]; // Element ist a[99]! 17

18 Fehler in C/C++ 7) double x, y, *pd; x= 4.1; y = 7.18; *pd = y; // formal korrekt aber Pointervariable pd ist noch // uninitialisiert (zeigt irgendwo hin) pd = x; // Wert zu Pointer ist verboten, richtig: pd = &x 8) class TIME{ public: void read_time(); void write_time(); void add_time(time t1, TIME t2); private: int hh, mm, ss; // hier wurde das abschließende Semikolon vergessen, richtig: ; 18

19 Fehler in C/C++ Laufzeitfehler: Ein syntaktisch korrektes Programm kann auch nach seinem Start während der Programmausführung mit einer Fehlermeldung abbrechen. Diese erst zur Laufzeit auftretenden Fehler heißen Laufzeitfehler. Beispiele: 1) Division durch Null:. cin >> n; q = z/n; // Abbruch, falls für n Null eingegeben wird... 2) Wurzel aus negativer Zahl:.... c = sqrt(x-y); // Abbruch, falls aktuell x-y <

20 Fehler in C/C++ Semantikfehler: (Logische Fehler) Semantikfehler verstoßen wird weder gegen Rechtschreib- noch gegen Grammatikregeln einer Sprache. Beispiel: Das Rad ist viereckig Wenn ein Programm ohne Fehlermeldungen abgearbeitet wird aber falsche Ergebnisse liefert, liegt ein logischer Fehler vor. Logische Fehler werden nur erkannt, wenn zu bestimmten Test-Eingaben die erwarteten Programm-Ergebnisse bekannt sind(z. B. durch Handrechnung oder Taschenrechner). Diese Fehler entstehen durch einen falschen Algorithmus und zwingen manchmal zu einer grundlegenden g Umorganisation des Programms. Beispiel: Statt Berechnung der Summe zweier Größen wird das Produkt gebildet. Ein solcher logischer Fehler kann natürlich auch auf einem Tippfehler beruhen. Fehler in der Logik größerer Programme lässt sich durch ein klares Konzept des Programmaufbaus(Struktogramm) vorbeugen. 20

21 Fehlerbehandlung Wie wird in normalen Programmen, z.b. C-Programmen, mit Fehlern umgegangen, die bei der Ausführung einer Funktion erkannt werden? Es gibt klassisch unter anderen, die folgenden Möglichkeiten: 1. Zurückgabe eines Funktionswert, der einen Fehler Signalisiert(z.B. -1) 2. Setzen eines Statusbits, in der Hoffnung, dass der Anwender diesen Wert auch abfragt; 3. Ausgabe einer Fehlermeldung ld und Programmabbruch mit exit(). Alle 3 haben schwäche: (1) ist anwendbar in Methoden/Funktionen, die gar keinen Rückgabewert zurückgeben. z.b in Konstruktoren to oder Destruktoren to e In (2) hofft man nur (3) ist oft zu drastisch! Mit Exceptions lassen sich solche Situationen sehr flexibel bahandeln. 21

22 Fehler und Nichtfehler Der Begriff Fehler wird hier eingeschränkt auf Fehler, die den normalen Programmablauf stören. Eine fehlerhafte Eingabe eines Benutzers ist in der Regel kein Fehler für ein Programm! Es sollte z.b. den Benutzer über die fehlerhafte Eingabe informieren und zu einer wiederholten Eingabe auffordern. Beim Traversieren einer Liste ist das Erreichen des Listenendes auch kein Fehler, sondern ein ganz normaler Zustand. Versucht ein Programm jedoch, ein Element hinter dem Listenende anzuschauen, ist es in der Regel ein Fehler. Ein typischer Fehler ist auch, auf ein Feldelement zuzugreifen, das nicht existiert. Ist ein Fehler eine wirkliche Ausnahme, das heißt, tritt er selten und kaum vorhersehbar auf, sind die obigen Fehlerbehandlungsarten nicht adäquat. 22

23 Ausnahmen Als Ausnahmen (exceptions ) werden Ereignisse bezeichnet, die bei der Ausführung eines Programms auftreten und die nicht im normalen Kontrollfluß des Programms behandelt werden. Es ist eine typische Ausnahme, wenn bei einer Gleitkommaoperation ein Überlauf stattfindet. Eine andere Ausnahme tritt z.b. auf, wenn die Kommunikationsverbindung zwischen zwei Prozessen während eines Datenaustausches abbricht. Ausnahmebehandlung (exception handling ) ist die Bearbeitung solcher Ereignisse innerhalb des Programms und die Unterstützung durch die Programmiersprache und das Laufzeitsystem. Ausnahmen sind somit eine spezielle Art von Fehlern und Ausnahmebehandlung eine spezielle Fehlerbehandlung. Die Abgrenzung zwischen normalen Fehlern und Ausnahmen ist unscharf und insbesondere anwendungsabhängig. 23

24 Ausnahmen Für die Ausnahmebehandlung bietet C++ einen Mechanismus an, von der Stelle in einer Funktion, in der eine Ausnahme auftritt, die Kontrolle und Informationen an einen unbestimmten Aufrufer zu übergeben, der seine Bereitschaft erklärt hat, Ausnahmen eines bestimmten Typs zu behandeln. Die Ausnahmebehandlung wird im folgenden an einigen kleinen Beispielen eingeführt. Ein Ausnahmetyp wird durch eine ganz normale Klassendefinition iti festgelegt, t der außer am Namen nicht angesehen werden kann, dass es ein Ausnahmetyp ist. Ausnahmen melden Wenn eine Ausnahme erkannt wird, muss sie gemeldet werden: eine Ausnahme wird ausgeworfen. OOP und Angewandte Mathematik 24

25 Try und Catch Blöcke Einfache try und Catch Beispiel Im Block direkt nach dem Schlüsselwort try steht der Programmcode. Tritt jetzt innerhalb dieses Blocks eine Ausnahme auf, #include <iostream> using namespace std; so werden die darin folgenden Catch-Blöcke durchsucht, ob der momentan aufgetretene Ausnahmefall darin vorkommt. int main() { Wenn ja, so wird der entsprechende Catch-Block angesprungen. Die cout << "Start\n"; darin enthaltenen Befehle werden abgearbeitet. Anschließend wird mit dem nächsten Befehl nach dem letzten Catch-Block fortgesetzt. try { // Programmcode, der untersucht wird catch ( /* Fall 1 */ ) { // Fehlerbehandlung zu Fall 1 catch ( /* Fall 2 */ ) { // Fehlerbehandlung zu Fall 2 try { cout << "Inside try block\n"; throw 1; // throw an error cout << "This will not execute"; catch (int i) { // catch an error cout << "Caught an exception -- value is: "; cout << i << "\n"; cout << "End"; return 0; 25

26 Try und Catch Blöcke Wird der aufgetretene Fehlerfall in keinem Catch- Block abgefangen, so wird der Fehler an den übergeordneten Block weitergeleitet. Existiert kein übergeordneter Try-Catch-Block mehr oder wird dieser Fehler auch dort nicht behandelt, so löst das Laufzeitsystem einen Laufzeitfehler aus. Try-Catch-Blöcke dürfen beliebig geschachtelt werden. Im Ausnahmefall werden zunächst die Catch-Blöcke durchsucht, die zum aktuell durchlaufenen Try-Block gehören. Behandelt kein Catch-Block diese Ausnahme, so werden die Catch-Blöcke des übergeordneten Try- Catch-Blockes durchsucht und so fort. Ausnahmen können direkt vom System ausgelöst werden (Laufzeitfehler), aber auch der Programmierer selbst kann gezielt Ausnahmen erzögen; man spricht hier von einer Ausnahme werfen. Hierzu dient das Schlüsselwort throw. 26

27 Überladung von Operatoren Gewöhnliche Operatoren können überladen werden. Man versteht schon: 1+2 = 3. Aber wenn wir + in einer Klasse überladen, sieht es so etwa aus: Class MyClass{ private: int x, y; public: MyClass(); MyClass Operator +(MyClass obj1){ MyClass temp; temp.x = x + obj1.x; temp.y = y + obj1.y; return temp; ; In der Main-Methode kann man zwei Objekte von typ MyClass mit + addieren. 27

28 UML (Klassendiagramme) Klassendiagram: Immer in drei Abteilungen für Klassenname, Variablen(Daten) und Methoden Klassenname-Block Eigenschaften immer hier (Attribute, Variablen) Methoden (Operationen, Funktionen) 28

29 UML (Klassendiagramme) Klassendiagram mit Attribute(Daten) 29

30 UML (Klassendiagramme) Klassendiagram mit methoden(operationen) 30

31 UML (Klassendiagramme) Vererbung 31

32 UML (Klassendiagramme) Komposition (echte Aggregation): Komponenten sind vom Aggregat existenzabhängig z.b. Arbeitsbereich ist Teil eine Universität. Aggregation (einfache Aggregation):Aggregat und Komponenten sind nicht existenzabhängig Häufig lässt sich nur schwierig festlegen, ob eine Aggregation oder Assoziation vorliegt. 32

33 UML (Klassendiagramme) Assoziationen : drückt das Verhältnis von zwei völlig selbständigen Objekten aus, die auf der gleichen Abstraktionsebene stehen und eigentlich nichts miteinander zu tun haben, aber unter bestimmten Gesichtspunkten in eine lose Kennt-Beziehung ('KNOWS') gebracht werden können. Bei einer m : n-beziehung wird dazu eine neue Klasse gebildet, deren Exemplare (Linkobjekt) die aktuelle Beziehung realisieren. 33

34 UML (Klassendiagramme) Kardinalität Dabei werden drei Grundtypen unterschieden: -1: 1-1: n -m: n Andere Notationen ti (UML) sind: 1 : genau eine 0,1 : konditionell, keine oder eine * : multiple, keine Einschränkung 0..* : multiple 1..* : mindestens eine 34