Einführung in das Programmieren für Technische Mathematiker

Transkript

1 Einführung in das Programmieren für Technische Mathematiker Einführung in C++ Marcus Page, MSc. Prof. Dr. Dirk Praetorius Fr. 10:15-11:45, Freihaus HS 8 Institut für Analysis und Scientific Computing

2 C++ Was ist C++ Programmierparadigmen C++ im Vergleich mit C 1

3 Programmierparadigmen fundamentaler Programmierstil Sprachen unterscheiden sich im Aufbau Klassifizierung von Programmiersprachen Es geht nicht um das was sondern um das wie bestimmen Entwurf und Design von PS Imperativ, Deklarativ, Objektorientiert 2

4 Imperative Programmierparadigmen (Assemblersprachen) Strukturierte Programmierung Prozedurale Programmierung Modulare Programmierung 3

5 Assemblersprachen sehr maschinennahe Programmierung abhängig von der aktuellen Architektur keine Schleifen / Strukturen wie etwa in C Kenntnis des Prozessors wichtig manueller Zugriff auf einzelne Register Beispiel "Hello World" 1.data 2 out:.asciiz "Hallo Welt" 3 # die Zeichenkette zum Ausgeben (als Label) 4 5.text 6 main: li $v0, 4 7 # Befehl 4 ( print_string ) in Register schreiben 8 9 la $a0, out 10 # Argument für den Systemaufruf in das 11 # Argumentregister schreiben syscall 14 # Ausführung der Systemfunktion (Ausgabe) li $v0, # Befehl 10 ( exit ) in Register schreiben syscall 20 # Ausführung der Systemfunktion (Programmende) 4

6 Strukturierte Programmierung Im Laufe der Zeit wurden Programme größer mehr Leute mussten programmieren manuelle Registerzuweisung zu aufwändig leicht verständliche Sprachen nötig Programmierer konzentriert sich auf Problem nicht auf technischen Hintergrund Strukturen wurden wichtig Programme müssen lesbarer werden einfache Schleifen / Verzweigungen Beispiel: BASIC 5

7 Strukturierte Programmierung Beispiel in BASIC 1 10 INPUT "What is your name: ", U$ 2 20 PRINT "Hello "; U$ 3 30 INPUT "How many stars do you want: ", N 4 40 S$ = "" 5 50 FOR I = 1 TO N 6 60 S$ = S$ + "*" 7 70 NEXT I 8 80 PRINT S$ 9 90 INPUT "Do you want more stars? ", A$ IF LEN(A$) = 0 THEN GOTO A$ = LEFT$(A$, 1) IF A$ = "Y" OR A$ = "y" THEN GOTO PRINT "Goodbye "; U$ END Ausgabe: What is your name: Mike Hello Mike How many stars do you want: 7 ******* Do you want more stars? yes How many stars do you want: 3 *** Do you want more stars? no Goodbye Mike 6

8 Prozedurale Programmierung Probleme werden komplexer Programme werden länger Ideen: Wartebarkeit, Wiederverwendbarkeit einzelne Komponenten auslagern einzeln testen später zusammenfügen verwende Blöcke Beispiele: Fortran, COBOL, C, Pascal 7

9 Prozuderale Programmierung Beispiel in PASCAL 1 program stars; 2 3 procedure plotstars(amount : integer); 4 var 5 i : integer; 6 begin 7 for i := 1 to amount do write( * ); 8 writeln( ); 9 end; var 12 amount : integer; 13 answer : char; 14 begin 15 repeat 16 writeln( how many stars do you want? ); 17 readln(amount); 18 plotstars(amount); 19 writeln( do you want more stars? (y/n) ); 20 readln(answer); 21 until answer <> y ; 22 end. Ausgabe: how many stars do you want? 12 ************ do you want more stars? (n) n 8

10 Modulare Programmierung verbinde kleinere Programmteile zu Modulen Daten werden gebündelt weitere Erhöhung der Übersichtlichkeit Erhöhung der Wiederverwendbarkeit benutze alles wieder soweit es geht verringert Fehlerquellen spart Arbeit Beispiele: Modula-2, Oberon, Ada, (C) Beispiel: Struktur Shape 1 #include <stdio.h> 2 3 typedef struct _Shape_ 4 { 5 // type 1 = line, type 2 = square 6 int type; 7 int size; 8 } Shape; 9

11 Modulare Programmierung 1 void plotshape(shape s) 2 { 3 int i, j; 4 if (s.type == 1) 5 { 6 for (i = 1; i <= s.size; i++) 7 {printf("*");} 8 printf("\n"); 9 } 10 else 11 { 12 for (i = 1; i <= s.size; i++) 13 { 14 for (j = 1; j <= s.size; j++) 15 {printf("*");} 16 printf("\n"); 17 }}} int main (int argc, const char * argv[]) 20 { 21 Shape myshape, myshape2; 22 myshape.type = 1; 23 myshape.size = 3; 24 myshape2.type = 2; 25 myshape2.size = 4; plotshape(myshape); 28 plotshape(myshape2); 29 } Ausgabe: *** **** **** **** **** 10

12 Objektorientierte Programmierung Problem: einfache Module zu unflexibel lässt sich nicht auf beliebige Formen anwenden was passiert bei Rechtecken (zwei Größen)? Daten lassen sich schlecht mit Funktionen kapseln Software schlecht zu warten Idee: Gemeinsamkeiten nur einmal programmieren nur Unterschiede abwandeln Vererbung Klassenhierarchie Kapsle Daten mit Funktionen Beispiele: C++, Java 11

13 Objektorientierte Programmierung alle Typen können auf plot zugreifen Rechteck sind nur mehrere Linien... 12

14 Generische Programmierung stellen eine Weiterentwicklung der OO dar Algorithmen für allgemeine Datentypen parametrische Polymorphie Code möglichst allgemein generieren im Anwendungsfall konkretisieren z.b.: Sortieralgorithmen nicht nur für Zahlen, Strings Beispiele: C++, Java 13

15 Deklarative Programmierung Beschreibung des Problems steht im Vordergrund Lösungsweg wir automatisch ermittelt es geht darum was gelöst werden soll das wie ist nicht so relevant verwendet hauptsächlich Rekursion funktionale Sprachen keine Anweisungen, nur Ausdrücke Beispiele: LISP, ProLog, SQL, Haskell quicksort [] = [] quicksort (x:xs) = quicksort [n n<-xs, n<x] ++ [x] ++ quicksort [n n<-xs, n>=x] 14

16 Klassifikation von Programmiersprachen 15

17 sonstige Unterschiede zwischen Programmiersprachen Compiler / Interpreter wann wird Code übersetzt / ausgeführt auch Mischung möglich Plattformunabhängigkeit Internetanwendungen Verbreitung der Sprache gibt es Bibliotheken / support / Foren Ziele der Sprache warum wurde die Sprache entwickelt? (universell / speziell / Lernzwecke) jede Sprache hat Vor- und Nachteile es gibt für jede Sprache sinnvolle Probleme beliebige Programme immer möglich aber: Starcraft II, Photoshop in Assembler? Treiber in Java? 16

18 Hello World in Brainfuck Ziel: Turing-vollständige PS mit kleinem Compiler kompletter Befehlssatz enthält 8 Befehle Compiler mit 98 Bytes (MS-DOS) [ Vorbereitende Schleife 3 > > >+++>+<<<<- 4 ] 5 >++. Ausgabe von H 6 >+. Ausgabe von e l 8. l o 10 >++. Leerzeichen 11 << W 12 >. o r l d 16 >+.! 17 >. Zeilenvorschub Wagenrücklauf 17

19 Was ist C++ Eine Weiterentwicklung von C Verwendung neuer Programmierparadigmen Erlaubt völlig neue Lösungswege Erlaubt problemnahe Programmierung Ziele beim Entwickeln der Sprache Kompatibilität keine Änderung der Syntax Vielseitige Einsetzbarkeit (Eigene Datentypen können entworfen werden) Verwaltungsaufwand minimieren Strukturierung erleichtern Strenge Typisierung (erleichtert Fehlerfindung) Stärkere Zugriffskontrolle 18

20 Good to know C++ ist eine höhere Programmiersprache Entwicklung ab 1979 bei AT&T Entwickler: Bjarne Stroustrup Erweiterung von C Einführung eines Klassenkonzeptes (C with classes) bessere Wiederverwendbarkeit bessere Wartbarkeit Abwärtskompatibel (zu C) keine Syntaxkorrektur Heute: voll objektorientiert ISO genormt Inspiration für andere Sprachen C#, Java Compiler: g++, gpp frei verfügbar Microsoft Visual C++ Compiler Borland C++ Compiler 19

21 Was kann mir helfen? Endlose Anzahl an Büchern Die C++ Programmiersprache Jetzt lerne ich C++ C++ in 21 Tagen C++ für C Programmierer Online Tutorien einfach googlen C++ API C++ Befehlsreferenz Entwicklungsumgebungen engl. Integrated Development Environment (IDE) Erleichtern das Programmieren selbst farbliches Hervorheben automatisches Einrücken automatische Codeergänzung code folding debugger 20

22 Einige C++ IDEs Netbeans (frei verfügbar) Eclipse (frei verfügbar) Microsoft Visual Studio (sauteuer) Microsoft Visual Studio Express (frei) Xcode (frei für Mac OS) App Store ;) können mehr als nur C++ werden in der Übung angeschaut 21

23 Standardbibliothek Ausgaben Eingaben Strings Container 22

24 Hello World 1 #include <iostream> 2 3 int main() 4 { 5 std::cout << "Hello World!\n"; 6 return 0; 7 } Speichern unter helloworld.cpp Standardbibliothek für Ein- und Ausgabe in C++ heißt iostream cout ist der Standard-Ausgabestream kann unterschiedliche Datentypen übernehmen Notation :: deklariert den Namensbereich Operator «übergibt sein zweites Argument an den Ausgabestream main hat Rückgabewert int 1 #include <iostream> 2 using namespace std; 3 4 int main() 5 { 6 cout << "Hello World!\n"; 7 return 0; 8 } Ausgabe: Hello World! mehr zu namespaces später 23

25 Datentyp string 1/2 1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 int main() { 6 string str1 = "Hallo"; 7 string str2 = "Welt"; 8 string str3 = str1 + " " + str2; 9 10 cout << str3 << "!\n"; 11 str3.replace(6,4, "Peter"); 12 cout << str3 << "!\n"; 13 } Ausgabe: Hallo Welt! Hallo Peter! Strings sind mächtiger als char* liefert eine Reihe nützlicher Operationen + zur Konkatenation replace zum ersetzen von Teilstrings substr zum auslesen von Teilstrings length zum auslesen der Länge u.v.m. Datentypen können Methoden haben Prinzip der Datenkapselung Sie enthalten mehr als nur die Zeichen (Unterschied zu C) 24

26 Datentyp string 2/2 1 #include <iostream> 2 #include <string> 3 #include <stdio.h> 4 using namespace std; 5 6 int main() { 7 string str1 = "Hallo"; 8 string str2 = "Welt"; 9 string str3 = str1 + " " + str2; printf("%s\n", str3.c_str()); 12 cout << str3 << "\n"; 13 } Ausgabe: Hallo Welt Hallo Welt Inhalt mittels c str() erreichbar Das sind die bekannten char-arrays aus C Zugriff über name.c str() können mittels printf ausgegeben werden Wichtig: string char-array 25

27 Datentyp bool in C gibt es keinen logischen Datentyp Abhilfe schafft Interpretation 0 = false 1 = true das könnte so aussehen: #define false 0 #define true 1 typedef int bool; könnte aber auch mit Abfragen gelöst werden C++ enthält logischen Datentyp bool Werte true und false implizite Konversion arithmetischer Typen 0 entspricht false alles andere entspricht true 26

28 Eingaben 1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 int main() 6 { 7 string str; 8 cout << "Geben Sie Ihren Namen ein\n"; 9 cin >> str; 10 cout << "Hallo " << str << "!\n"; 11 } Eingabe: Praetorius Ausgabe: Hallo Praetorius! Eingabe: Dirk Praetorius Ausgabe: Hallo Dirk! Verwende getline für ganze Zeile 1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 int main() 6 { 7 string str; 8 cout << "Geben Sie Ihren Namen ein\n"; 9 getline(cin, str); 10 cout << "Hallo, " << str << "!\n"; 11 } Eingabe: Dirk Praetorius Ausgabe: Hallo, Dirk Praetorius! 27

29 Vektoren Verwendung als dynamische Arrays ohne alloc, malloc sind Container für beliebige Datentypen (mehr dazu später) 28

30 Vektoren 1/3 1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 struct Eintrag { 6 string name; 7 int nummer; 8 }; 9 10 int main() 11 { 12 Eintrag telbuch[3]; 13 telbuch[0].name = "Peter Pan"; 14 telbuch[1].name = "Wolverine"; 15 telbuch[2].name = "Angela Merkel"; 16 cout << telbuch[2].name + "\n"; 17 } Ausgabe: Angela Merkel Verwendung sinnvoll falls Größe bekannt Problem: Speicher nicht dynamisch erweiterbar Lösung in C: Pointer, malloc, realloc sehr mühsam und unübersichtlich Lösung in C++: Vektoren 29

31 Vektoren 2/3 1 #include <iostream> 2 #include <string> 3 #include <vector> 4 using namespace std; 5 6 struct Eintrag { 7 string name; 8 int nummer; 9 }; int main() 12 { 13 vector<eintrag> telbuch(3); 14 telbuch[0].name = "Peter Pan"; 15 telbuch[1].name = "Wolverine"; 16 telbuch[2].name = "Angela Merkel"; 17 cout << telbuch[2].name + "\n"; 18 } Ausgabe: Angela Merkel Vektoren sind C++ Standardcontainer können beliebige Datentypen übernehmen dienen zum Verwalten von Datenmengen Verwendung: vector<type> name(size); Achtung, nicht verwechseln: vector<eintrag> buch(1000); 1000 Elemente vector<eintrag> buecher[1000]; 1000 Vektoren 30

32 Vektoren 3/3 1 #include <iostream> 2 #include <string> 3 #include <vector> 4 using namespace std; 5 6 struct Eintrag { 7 string name; 8 int nummer; 9 }; int main() 12 { 13 vector<eintrag> telbuch(3); 14 telbuch[0].name = "Peter Pan"; 15 cout << "size: " << telbuch.size() << endl; 16 telbuch.resize(telbuch.size()+4); 17 cout << "size: " << telbuch.size() << endl; 18 } Ausgabe: size: 3 size: 7 Speicher dynamisch veränderbar mittels resize Viele hilfreiche Funktionen: size push back, pop back insert front, back uvm. endl bewerkstelligt Zeilenumbruch 31

33 weitere Standardcontainer list queue stack deque set priority queue set multiset map multimap 32

34 Ratschläge und Unterschiede zu C Bibliotheken verwenden API verwenden Standardbibliothek eher als andere string anstelle von char* vector<t> anstelle von T[] cout anstelle von printf Std. Bibliothek verwendet den Namensbereich std 33

35 Objektorientiertes Design Klassen Typen Objekte 34

36 Was sind Klassen Klassen sind benutzerdefinierte Datentypen Verwendung völlig analog zu int, string Klassen erweitern struct aus C erlauben Methoden (Funktionen) Klassen erlauben das Prinzip der Datenkapselung Code wird besser wiederverwendbar black-box-implementierung möglich Klassen sind Schablonen für Objekte Klassen sind der Grundbaustein zur OO Vergleich zu C Klasse = typedef + struct 35

37 Beispiel 1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 class Student 6 { 7 string name; 8 string studiengang; 9 int matrikelnummer; void lernen(); 12 void testschreiben(); 13 }; Deklaration mit Schlüsselwort class enthält Daten (members) analog zu struct aus C enthält Funktionen (Methoden) erlaubt es komplette Objekte abzubilden zu Namenskonvention: C++ ist case sensitive Groß- und Kleinschreibung beachten Klassen (Coding Standard) AlleWorteCapitalizedOhneUnderlines Methoden, Funktionen und Variablen ersteswortkleinrestcapitalizedohneunderlines 36

38 Objekte Objekte sind Instanzen einer Klasse Sie sind die tatsächlichen Variablen werden angelegt wie bei primitiven Typen entsprechen Variablen vom struct Datentyp Student Marcus; int x; Zugriff auf Klassenelemente mit Punktoperator (.) Marcus.name = "Marcus Page"; Marcus.lernen(); Achtung: An Objekte zuweisen, nicht an Klassen int = 5; Student = "Marcus Page"; // Fehler // Fehler 37

39 Zugriffskontrolle Klassen und Objekte dienen der Abstraktion genaue Implementierung nicht wichtig zum Beispiel durch Bibliotheken Benutzer soll so wenig wissen wie möglich black-box Programmierung nur Ein- und Ausgabe müssen bekannt sein richtiger Zugriff muss sichergestellt werden Schlüsselwörter private und public private (Standard) Zugriff nur von Methoden der gleichen Klasse public erlaubt Zugriff von überall protected teilweiser Zugriff von außen (später) 38

40 Beispiel 1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 class Student 6 { 7 private: 8 string studiengang; 9 10 public: 11 string name; 12 int matrikelnummer; 13 void lernen(); 14 void testschreiben(); 15 }; int main() 18 { 19 Student Marcus; 20 Marcus.name = "Marcus Page"; 21 Marcus.matrikelnummer = ; 22 Marcus.studiengang = "Mathematik"; 23 } Fehler in Zeile 22: std::string student::studiengang is private 39

41 Klassenmethoden implementieren 1 class Student 2 { 3 public: 4 string name; 5 int matrikelnummer; 6 void lernen(); 7 void testschreiben(); 8 }; 9 10 void Student::lernen() 11 { 12 cout << "oh mann..." << endl; 13 } void Student::testSchreiben() 16 { 17 cout << "geschafft!" << endl; 18 } int main() 21 { 22 Student Marcus; 23 Marcus.lernen(); 24 Marcus.testSchreiben(); 25 } Ausgabe: oh mann... geschafft! Implementierung wie bei anderen Funktionen Zugehörigkeit zur Klasse durch (::) student :: testschreiben() Deklaration auch in Header-Datei möglich (wie C) 40

42 Deklaration in Header-Datei student4.h 1 #include <string> 2 using namespace std; 3 4 class Student 5 { 6 public: 7 string name; 8 int matrikelnummer; 9 void lernen(); 10 void testschreiben(); 11 }; student4.cpp 1 #include <iostream> 2 #include "student4.h" 3 using namespace std; 4 5 void Student::lernen() 6 { 7 cout << "oh mann..." << endl; 8 } 9 10 void Student::testSchreiben() 11 { 12 cout << "geschafft!" << endl; 13 } int main() 16 { 17 Student Marcus; 18 Marcus.lernen(); 19 Marcus.testSchreiben(); 20 } 41

43 Methoden Implementieren 2 1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 class Student 6 { 7 public: 8 string name; 9 int matrikelnummer; 10 void lernen(){cout << "oh mann..." << endl;}; 11 void testschreiben(){cout << "geschafft!" 12 << endl;}; 13 }; int main() 16 { 17 Student Marcus; 18 Marcus.lernen(); 19 Marcus.testSchreiben(); 20 } Implementierung direkt bei der Klassendefinition nach Definition in geschweiften Klammern {} bietet sich an für kurze Methoden (get, set) häßlich und unübersichtlich für längere 42

44 Klassen auslagern 1/2 Klasse in Datei auslagern 1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 class Student 6 { 7 public: 8 string name; 9 int matrikelnummer; 10 void lernen(); 11 void testschreiben(); 12 }; void Student::lernen() 15 { 16 cout << "oh mann..." << endl; 17 } void Student::testSchreiben() 20 { 21 cout << "geschafft!" << endl; 22 } mit include einbinden 1 #include "student6.cpp" 2 3 int main() 4 { 5 Student Marcus; 6 Marcus.lernen(); 7 Marcus.testSchreiben(); 8 } unschön (siehe nächste Folie) 43

45 Klassen auslagern 2/2 besseres Vorgehen: 3 Dateien student6.h student6.cpp prog.cpp kompilieren mittels: g++ -c student6.cpp g++ -c prog.cpp g++ -o prog prog.o student.o Analog zu C! 44

46 Wozu Zugriff einschränken? 1/3 1 #include <iostream> 2 using namespace std; 3 4 class Ratio 5 { 6 public: 7 int z, n; //ratio = z/n 8 }; 9 10 int main() 11 { 12 Ratio myratio; 13 myratio.z = -1000; 14 myratio.n = 0; 15 } wie sinnvolle Werte sicherstellen? (Z. 14) mögliche Fehlerquellen direkt ausschließen Programmierer muss sich um möglichst wenig kümmern 45

47 Wozu Zugriff einschränken? 2/3 1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 class Car 6 { 7 public: 8 int wert; 9 string farbe; 10 }; int main() 13 { 14 Car TestCar; 15 TestCar.wert = -1000; 16 int preis = TestCar.wert - 500; 17 } wie sinnvolle Werte sicherstellen? (Z. 15) was wenn sich Implementierung ändert? Preis könnte sich neu berechnen (Z. 16) zum Beispiel durch neue Version kompletten Code umschreiben 46

48 Wozu Zugriff einschränken? 3/3 1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 class Car 6 { 7 private: 8 int wert; 9 string farbe; 10 public: 11 int getpreis(){return wert - 500;}; 12 void setpreis(int x); 13 }; void Car::setPreis(int x) 16 { 17 if(x < 500){wert = 500;} 18 else{wert = x;}; 19 } int main() 22 { 23 Car TestCar; 24 TestCar.setPreis(-1000); 25 cout << TestCar.getPreis() << endl; 26 } Ausgabe: 0 vermeidet inkonsistente Objekte Änderung der Preisberechnung nur eine Methode umschreiben 47

49 warum so viel Kontrolle? Fakt ist: alle Programmierer machen Fehler Code läuft beim ersten mal nie richtig Großteil der Entwicklungszeit geht in Fehlersuche Wie unterscheiden sich Profis von Anfängern? durch effizientere Fehlersuche Compiler-Fehler sind leicht einzugrenzen es steht sogar die Zeilennummer dabei 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 möglichst viele Fehler durch Compiler abfangen Methoden werden mit Verstand geschrieben das sollte sich im Code wiederspiegeln gehören Daten strikt zu einer Klasse private Zugriff kontrollieren mittels get und set (reine Daten sollten immer private sein) 48

50 Namensgleichheit 1 /* class definitions */ 2 3 void Student::print() 4 { 5 cout << "Name: " << name << endl; 6 cout << "Mat. Nu.: " << matrikelnummer << endl; 7 } 8 9 void Car::print() 10 { 11 cout << "Wert: " << wert << endl; 12 cout << "Farbe: " << farbe << endl; 13 } int main() 16 { 17 Student Marcus; 18 Marcus.name = "Marcus Page"; 19 Marcus.matrikelnummer = ; 20 Car TestCar; 21 TestCar.farbe = "Dakota Beige"; 22 TestCar.wert = 10000; Marcus.print(); 25 TestCar.print(); 26 } Ausgabe: Name: Marcus Page Mat. Nu.: Wert: Farbe: Dakota Beige Es wird immer die zugehörige Funktion aufgerufen Punktoperator: Marcus.print(); 49

51 Übersicht Klassen Klassen sind benutzerdefinierte Datentypen zentrale Datenstruktur der OO Programmierung Sie erlauben Datenkapselung Sie erlauben Datenabstraktion Kenntnis der Implementierung nicht nötig warten / wiederverwenden / weitergeben leicht ermöglichen kontrollierte Zugriffe verwende private Daten verwende get und set Methoden komplette Objekte können nachgebaut werden enthalten mehr als nur die reinen Werte keine Probleme durch doppelte Namensgebung 50

52 Objekte inititalisieren Klassen können viele Daten haben bislang: alle einzeln inititalisieren 1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 class Car{ 6 private: 7 int preis; 8 int speed; 9 int age; 10 string farbe; /* public get and set methods */ 13 }; int main() 16 { 17 Car TestCar; 18 TestCar.setPreis(1000); 19 TestCar.setFarbe("Dakota Beige"); 20 TestCar.setSpeed(150); 21 TestCar.setAge(3); 22 } mühsam besonders für Große Objekte mühsam wenn mehrere Objekte angelegt werden besser direkt bei der Initialisierung spezielle Methoden (Konstruktoren) heißen wie die Klasse selbst 51

53 Konstruktoren 1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 class Car{ 6 private: 7 int preis; 8 int speed; 9 int age; 10 string farbe; 11 public: 12 Car(int p, int s, int a, string f); 13 }; Car::Car(int p, int s, int a, string f) 16 { 17 preis = p; 18 speed = s; 19 age = a; 20 farbe = f; 21 } int main() 24 { 25 Car TestCar1(1000, 150, 3, "Dakota Beige"); 26 Car TestCar2(3700, 100, 6, "Feuerrot"); 27 } Konstruktoren dienen zum initialisieren werden automatisch aufgerufen Standardkonstruktor wenn kein anderer definiert es kann mehrere in einer Klasse geben 52

54 Konstruktoren 2 1 /* class definition */ 2 3 Car::Car(int p, int s, int a, string f): 4 preis(p), speed(s), age(a),farbe(f){} 5 6 Car::Car(int preis, int speed) 7 { 8 this->preis = preis; 9 this->speed = speed; 10 this->age = 10; 11 this->farbe = "unknown"; 12 } alle Konstruktoren heißen wie die Klasse unterscheiden sich durch ihre Signatur Kurzschreibweise mittels Doppelpunkt (:) (Z. 4) direkte Zuweisung an Membervariablen Standardkonstruktor nur wenn es keinen anderen gibt der Zeiger this Zeiger der auf das Objekt selbst zeigt kann lokale Namensgleichheiten auflösen nützlich wenn man das Objekt übergeben muss 53

55 Destruktoren 1 /* includes and namespace definition */ 2 3 class Car{ 4 private: 5 6 /* private member definition */ 7 8 public: 9 Car(int p, int s, int a, string f); 10 ~Car(){}; 11 }; /* constructor definition */ int main() 16 { 17 Car TestCar1(1000, 150, 3, "Dakota Beige"); 18 Car TestCar2(3700, 100, 6, "Feuerrot"); 19 } werden beim Auflösen des Objektes aufgerufen heißen wie die Klasse mit Tilde ( ) Standarddestruktor wird ggfs. automatisch generiert kompliziertere Objekte müssen aufgeräumt werden Objekt könnte auch Netzwerk-Socket sein muss geschlossen werden evtl. Buffer leeren... 54

56 Überladen Überladen von Funktionen Überladen von Operatoren Was überlädt man? 55

57 Überladen von Funktionen 1 #include <iostream> 2 using namespace std; 3 4 class Car 5 { 6 private: 7 int preis; 8 int speed; 9 public: 10 Car(int p, int s){preis=p; speed=s;}; 11 void drive(); 12 void drive(int km); 13 }; void Car::drive() 16 { 17 cout << "10 km gefahren" << endl; 18 } void Car::drive(int km) 21 { 22 cout << km << " km gefahren" << endl; 23 } int main() 26 { 27 Car TestCar(1000,150); 28 TestCar.drive(); 29 TestCar.drive(35); 30 } Ausgabe: 10 km gefahren 35 km gefahren 56

58 Überladen von Funktionen 2 1 #include <iostream> 2 using namespace std; 3 4 class Real 5 { 6 private: 7 double value; 8 public: 9 Real(double v){value = v;}; 10 double getvalue(){return value;}; 11 void print(); 12 void print(int nks); 13 }; void Real::print() 16 { 17 cout.precision(6); 18 cout << getvalue() << endl; 19 } void Real::print(int nks) 22 { 23 cout.precision(nks); 24 cout << getvalue() << endl; 25 } int main() 28 { 29 Real myreal( ); 30 myreal.print(); 31 myreal.print(10); 32 } Ausgabe:

59 Standardwerte 1 #include <iostream> 2 using namespace std; 3 4 class Real 5 { 6 private: 7 double value; 8 public: 9 Real(double v){value = v;}; 10 double getvalue(){return value;}; 11 void print(int nks = 10); 12 }; void Real::print(int nks) 15 { 16 cout.precision(nks); 17 cout << getvalue() << endl; 18 } int main() 21 { 22 Real myreal( ); 23 myreal.print(); 24 myreal.print(4); 25 } Ausgabe:

60 Überladen von Funktionen mehrere Funktionen gleichen Namens möglich analog zu Konstruktoren unterscheiden sich durch ihre Signatur diesen Vorgang nennt man überladen durch Aufruf wird die richtige ausgewählt Compiler erkennt dies über Signatur Standardwerte können direkt gesetzt werden sinnvoll wenn Änderungen nur marginal nicht gut wenn z.b. andere Algorithmen nötig 59

61 Überladen von Operatoren 1 #include <iostream> 2 using namespace std; 3 4 class Complex 5 { 6 private: 7 double vreal; 8 double vimag; 9 public: 10 Complex(double r, double i); 11 double getreal(){return vreal;}; 12 double getimag(){return vimag;}; 13 void setreal(double r){vreal = r;}; 14 void setimag(double i){vimag = i;}; 15 void print(); 16 }; Complex::Complex(double r, double i) 19 { 20 vreal = r; 21 vimag = i; 22 } void Complex::print() 25 { 26 cout << getreal() << " + " << getimag() 27 << "i" << endl; 28 } int main() 31 { 32 Complex mycomplex(3, 5); 33 mycomplex.print(); 34 } Ausgabe: 3 + 5i 60

62 Überladen von Operatoren 2 1 #include <iostream> 2 using namespace std; 3 4 class Complex 5 { 6 /* private data */ 7 public: 8 Complex(double r = 0, double i = 0); 9 Complex add(complex rhs); /* remaining public data */ 12 }; /* constructor and print definition */ Complex Complex::add(Complex rhs) 17 { 18 double rtmp = getreal() + rhs.getreal(); 19 double itmp = getimag() + rhs.getimag(); 20 return Complex(rTmp, itmp); 21 } int main() 24 { 25 Complex mycomplex(3, 5), mycomplex2(2, 7); 26 Complex mycomplex3; 27 mycomplex3 = mycomplex.add(mycomplex2); 28 mycomplex.print(); 29 mycomplex2.print(); 30 mycomplex3.print(); 31 } Ausgabe: 3 + 5i 2 + 7i i 61

63 Überladen von Operatoren 3 1 #include <iostream> 2 using namespace std; 3 4 class Complex 5 { 6 /* private data */ 7 public: 8 Complex(double r = 0, double i = 0); 9 Complex operator+(complex rhs); /* remaining public data */ 12 }; /* constructor and print definition */ Complex Complex::operator+(Complex rhs) 17 { 18 double rtmp = getreal() + rhs.getreal(); 19 double itmp = getimag() + rhs.getimag(); 20 return Complex(rTmp, itmp); 21 } int main() 24 { 25 Complex mycomplex(3, 5), mycomplex2(2, 7); 26 Complex mycomplex3; 27 mycomplex3 = mycomplex + mycomplex2; 28 mycomplex.print(); 29 mycomplex2.print(); 30 mycomplex3.print(); 31 } Ausgabe: 3 + 5i 2 + 7i i 62

64 Überladen von Operatoren 4 Operatoren selbst können überladen werden mittels Schlüsselwort operator wie im Beispiel operator+ Methode add funktioniert auch ist aber viel mühsamer in der Verwendung vgl. Syntax: mycomplex3 = mycomplex.add(mycomplex2); mycomplex3 = mycomplex + mycomplex2; interne Auswertung: mycomplex3 = mycomplex.operator+(mycomplex2); Verwendung wird übersichtlicher Programm wird lesbarer Überladen sollte nur dafür verwendet werden (+) mit (-) zu überladen nicht ratsam Operatoren von Standardtypen können nicht überladen werden (z.b. int) Zusätzliche Operatoren können hier auch nicht definiert werden 63

65 was kann überladen werden + - * / & ˆ & ~! = < > += -= *= /= %= ˆ= &= = »= «= ==!= <= >= && ++ ->*, -> [] () new new[] delete delete[] unäre und binäre Operatoren unterscheide zwischen Postfix und Präfix leicht unterschiedliche Syntax operator kann natürlich auch überladen werden gemischte Arithmetik möglich z.b. complex + real 64

66 Überladen von typecasts 1 class Complex 2 { 3 /* private data */ 4 public: 5 Complex(int r){vreal = r; vimag = 0;}; 6 operator int(); 7 /* remaining public data */ 8 }; 9 10 Complex::operator int() 11 { 12 return int(vreal); 13 } int main() 16 { 17 Complex mycomplex(3, 5), mycomplex2(2, 7); 18 int x = 1; 19 mycomplex2.print(); 20 mycomplex2 = x; 21 mycomplex2.print(); 22 cout << x << endl; 23 x = mycomplex; 24 cout << x << endl; 25 } Ausgabe: 2 + 7i 1 + 0i 1 3 typecast in nativen Datentyp mittels operator type andere Richtung mittels Konstruktor 65

67 Anmerkung strings rückblickend: string ist eine Klasse mit vielen Methoden string überlädt Operatoren für genauere Informationen API checken Links: Klassendiagramm in UML Unified Modeling Language Modelierungssprache Softwaredesign zum 66

68 Vererbung was ist Vererbung? geerbte Felder und Methoden Methoden redefinieren Aufruf von Basismethoden 67

69 Was ist Vererbung im Alltag klassifizieren wir Objekte wir teilen unsere Umgebung in Kategorien ein ein Auto ist ein Fortbewegungsmittel ein Hund ist ein Säugetier eine SPD-Matrix ist immer noch eine Matrix alle Säugetiere können sich bewegen und atmen Hunde haben zusätzlich spezielle Eigenschaften... bellen, mit dem Schwanz wedeln... Die Kategorien lassen sich weiter unterteilen Ferrari und Porsche beschreiben spezielle Autos ganze Hierarchien entstehen Unterkategorien sind jeweils Erweiterungen Eigenschaften der Basiskategorie haben alle ist-ein-beziehung C++ stellt Kategorien durch Klassen dar spezielle werden von allgemeineren abgeleitet diesen Vorgang nennt man Vererbung 68

70 Was ist Vererbung 2 69

71 Was ist Vererbung 3 Alle Matrizen haben Einträge reguläre Matrizen sind invertierbar für SPD bietet sich zusätzlich Cholesky an... 70

72 Die Syntax der Vererbung Vererbung in C++ bildet Wirklichkeit ab Spezialisierung durch zusätzliche Methoden allgemeine Methoden sind direkt verfügbar Fähigkeit bewegen muss bei Auto nicht separat Syntax: implementiert werden das wurde von Fortbewegungsmittel geerbt class Car : public Fortbewegungsmittel Ableitung erfolgt durch (:) auto erbt alle Methoden und Felder von fortbewegungsmittel auto ist eine abgeleitete Klasse fortbewegungsmittel ist die Basisklasse 71

73 Ein Beispiel 1 #include <iostream> 2 #include <string.h> 3 using namespace std; 4 5 class Fortbewegungsmittel 6 { 7 protected: 8 double speed; 9 public: 10 Fortbewegungsmittel(){}; 11 ~Fortbewegungsmittel(){}; 12 Fortbewegungsmittel(double s){speed = s;}; 13 double getspeed(){return speed;}; 14 void setspeed(double s){speed = s;}; 15 void move(); 16 }; class Car : public Fortbewegungsmittel 19 { 20 private: 21 string color; 22 public: 23 Car(){}; 24 void fahren(); 25 string getcolor(){return color;}; 26 void setcolor(string c){color = c;}; 27 }; 72

74 Ein Beispiel - ctn d 1 /* class definitions */ 2 3 void Fortbewegungsmittel::print() 4 { 5 cout << "Geschwindigkeit: " << 6 getspeed() << endl; 7 } 8 9 void Fortbewegungsmittel::move() 10 { 11 cout << "Ich habe mich bewegt" << endl; 12 } void Car::fahren() 15 { 16 cout << "Ich bin gefahren" << endl; 17 } int main() 20 { 21 Fortbewegungsmittel fahrrad(10); 22 Car mycar; 23 mycar.setspeed(50); 24 mycar.setcolor("rot"); 25 fahrrad.move(); 26 mycar.fahren(); 27 mycar.move(); 28 } Ausgabe:Ich habe mich bewegt Ich bin gefahren Ich habe mich bewegt 73

75 Das Schlüsselwort protected Problem: private Daten sind bei abgeleiteten Klassen nicht verfürbar Deklaration als public nicht sinnvoll Lösung: protected Daten sind für alle abgeleiteten Klassen sichtbar für alle anderen jedoch wie private 1 class Basis 2 { 3 private: 4 int privat; 5 protected: 6 int protect; 7 public: 8 int publik; 9 }; class Abgelitten : public Basis 12 { 13 void zugriff() 14 { 15 a = privat; // Das gibt Ärger! 16 a = protect; // Das funktioniert. 17 a = publik; // Das funktioniert sowieso. 18 } 19 }; int main(){ 22 Basis myvar; 23 int a; 24 a = myvar.privat; // Das läuft nicht. 25 a = myvar.protect; // Das auch nicht. 26 a = myvar.publik; // Das funktioniert. 27 } 74

76 Konstruktoren der Basisklasse aufrufen Vererbung bedeutet eine ist-ein-beziehung Jedes Auto ist ein Fortbewegungsmittel Das merkt man am Aufruf Zuerst wird der Konstruktor der Basisklasse aufgerufen Danach der Konstruktor der abgeleiteten Klasse Bei Destruktoren anders herum Entsprechend stellen Konstruktoren oft Erweiterungen dar z.b. zusätzliche Felder werden initialisiert daher: Basisklassenkonstruktor aufrufen 1 Car::Car(double s, string c): 2 Fortbewegungsmittel(s), 3 color(c) 4 { 5 cout << "car-konstruktor" << endl; 6 } 75

77 Funktionen redefinieren 1/2 Funktionen können in der abgeleiteten Klasse komplett neu gestaltet (redefiniert) werden 1 void Fortbewegungsmittel::print() 2 { 3 cout << "Geschwindigkeit: " << getspeed() 4 << endl; 5 } 6 7 void Car::print() 8 { 9 cout << "Geschwindigkeit: " << getspeed() 10 << ", Farbe: " << getcolor() << endl; 11 } nicht verwechseln mit überladen mehrere Methoden mit unterschiedlicher Signatur in jedem Fall wird immer die richtige Methode aufgerufen 76

78 Funktionen redefinieren 2/2 Problem: Basismethoden werden verdeckt eine redefinierte Methode verdeckt alle Basismethoden 1 void Fortbewegungsmittel::print(); 2 void Fortbewegungsmittel::print(int s); 3 void Fortbewegungsmittel::print(int s, double c); 4 5 void Car::print(); 6 7 /* Implementierung */ 8 9 int main() 10 { 11 Car mycar; 12 mycar.print(); // OK 13 mycar.print(10); // funktioniert nicht 14 } kein Zugriff mehr auf überladene Basisfunktionen Lösung: Basisfunktion manuell aufrufen vollständigen Namen verwenden mycar.fortbewegungsmittel::print(10); 77

79 Ein Beispiel 1/3 1 #include <iostream> 2 using namespace std; 3 4 class Punkt{ 5 protected: 6 int x; 7 int y; 8 public: 9 Punkt(int x, int y); 10 int getx(){return x;}; 11 int gety(){return y;}; 12 void bewegen(int x, int y); //überladen 13 void bewegen(int x); 14 void bewegen(); 15 void print(); 16 void center(); 17 }; class Kreis : public Punkt{ 20 private: 21 int radius; 22 public: 23 Kreis(int x, int y, int radius); 24 int getrad(){return radius;}; 25 void bewegen(int r); //redefiniert 26 void print(); 27 }; unterscheide zwischen überladen und redefinieren 78

80 Ein Beispiel 2/3 1 Punkt::Punkt(int x, int y){ 2 this->x = x; 3 this->y = y;} 4 5 void Punkt::bewegen(int x, int y){ 6 this->x = this->x+x; 7 this->y = this->y+y;} 8 9 void Punkt::bewegen(int x){ 10 this->x = this->x+x;} void Punkt::bewegen(){ 13 this->x = this->x-3; 14 this->y = this->y-4;} void Punkt::print(){ 17 cout << "X: " << getx() << ", Y: " 18 << gety() << endl;} void Punkt::center(){ 21 x=0; y=0;} Kreis::Kreis(int x, int y, int radius): 24 Punkt(x,y) 25 { 26 this->radius = radius; 27 } void Kreis::bewegen(int r){ 30 x = x+radius+r;} void Kreis::print(){ 33 cout << "X: " << getx() << ", Y: " << 34 gety() << ", Radius: " << getrad() << endl;} 79

81 Ein Beispiel 3/3 1 int main() 2 { 3 Punkt P1(3,7); 4 P1.print(); 5 P1.bewegen(13); 6 P1.print(); 7 8 Kreis K1(3,7,12); 9 K1.print(); 10 K1.bewegen(3); 11 K1.print(); 12 K1.Punkt::bewegen(3,4); 13 K1.print(); 14 K1.center(); 15 K1.print(); 16 } Ausgabe:X: 3, Y: 7 X: 16, Y: 7 X: 3, Y: 7, Radius: 12 X: 18, Y: 7, Radius: 12 X: 21, Y: 11, Radius: 12 X: 0, Y: 0, Radius: 12 in UML: 80

82 Vererbung mit Matrizen 1/3 1 #include <iostream> 2 #include <vector> 3 using namespace std; 4 5 class Matrix{ 6 protected: 7 int m,n; //dimensions 8 vector<vector<double> > entries; 9 public: 10 int getm(){return m;}; 11 int getn(){return n;}; 12 void setm(int dim){m = dim;}; 13 void setn(int dim){n = dim;}; 14 double getentry(int i, int j){return entries[i][j];}; 15 void setentry(int i, int j, double entry); 16 Matrix(); 17 Matrix(int m, int n, int init); 18 }; class ComplexMatrix : public Matrix{ 21 private: 22 vector<vector<double> > imag; 23 public: 24 double getimagentry(int i, int j){return imag[i][j];}; 25 void setimagentry(int i, int j, double entry); 26 ComplexMatrix(); 27 ComplexMatrix(int m, int n, int init); 28 }; 81

83 Vererbung mit Matrizen 2/3 1 /* class definitions*/ 2 3 void Matrix::setEntry(int i, int j, double entry){ 4 if (i >= m j >= n){ 5 cout << "Index exceeds matrix dimensions" << endl; 6 }else{ 7 entries[i][j] = entry; 8 } 9 } Matrix::Matrix(): 12 m(1), n(1), 13 entries(vector<vector<double> >(m, vector<double>(n, 0))){} Matrix::Matrix(int m, int n, int init): 16 m(m), n(n), 17 entries(vector<vector<double> >(m, vector<double>(n, init))) 18 {} void ComplexMatrix::setImagEntry(int i, int j, double entry){ 21 if (i>m j > n){ 22 cout << "Index exceeds matrix dimensions" << endl; 23 }else{ 24 imag[i][j] = entry; 25 } 26 } ComplexMatrix::ComplexMatrix(): 29 imag(vector<vector<double> >(m, vector<double>(n, 0))){} ComplexMatrix::ComplexMatrix(int m, int n, int init): 32 Matrix(m,n,init), 33 imag(vector<vector<double> >(m, vector<double>(n, init))) 34 {} 82

84 Übersicht - Vererbung Vererbung macht den Code leichter zu warten Verebung erhöht die Wiederverwendbarkeit massiv genaue Implementierung der Basisklasse unwichtig abgeleitete Klasse erbt alle Methoden und Felder sofern der Zugriff dies erlaubt neue Implementierung für geerbte Methoden möglich Methoden redefinieren Achtung: verdeckt alle gleichnamigen Basismethoden (dies kann natürlich gewollt sein) Zugriff über vollen Funktionsnamen Fazit: verwende Vererbung immer wenn (sinnvoll) möglich verwende Code wieder wenn möglich senkt die Fehlerquote erleichtert spätere Änderungen 83

85 One more thing es muss nicht immer public vererbt werden Basisklasse abgeleitete Klasse public protected private public public protected private protected protected protected private private hidden hidden hidden Sichtbarkeit ändert sich durch Art der Vererbung Zugriff kann nur verschärft werden andere außer public machen selten Sinn 84

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

87 Pointer mit new dyn. Erzeugung von Objekten mit new statt malloc int* i1 = new int; *i1 = 25; Vergleich zu C int* i2 = malloc(sizeof(int)); *i1 = 25; Erzeugung von Arrays mittel new[] int* feld = new int[128]; Vergleich zu C int* feld2 = malloc(128*sizeof(int)); Speichergröße muss nicht angegeben werden 86

88 Freigabe mit delete Freigeben von Objekten mit delete statt free int* i1 = new int; delete i1; Vergleich zu C int* i2 = malloc(sizeof(int)); free(i2); Freigabe von Arrays mittel delete[] int* feld = new int[128]; delete[] feld; Vergleich zu C int* feld2 = malloc(128*sizeof(int)); free(feld2); nicht verwechseln: new, new[], delete, delete[] schlecht: int* t = new int[3]; delete t; vielleicht sogar noch schlechter: int* t = new int; delete[] t; 87

89 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 } Ausgabe: constructor Hello World! destructor Hello World! Zeiger nach delete auf 0 setzen (Z. 20) 88

90 Zusammenfassung 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 Rückgabewert ist der richtige Zeiger Speichergröße muss nicht angegeben werden malloc legt nur Speicher an keine Initialisierung durch malloc Konstruktor kann nicht mehr aufgerufen werden Speicher in Bytes muss angegeben werden Rückgabewert ist immer void* explizites type-cast notwendig (bei nativen Typen optional) delete löscht Speicher und ruft Destruktor auf free gibt nur Speicher frei Destruktor kann nicht mehr aufgerufen werden Fazit: Verwende new, delete mit C++ Verwende malloc, free mit C niemals die beiden vermischen z.b. new mit free freigeben es gibt keine Alternative zu realloc z.b. vector verwenden 89

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

92 Was ist eine Referenz Referenzen sind Aliasnamen Erzeugung mittels (&) nicht verwechseln mit Adressoperator ähnlich zu (*) int &someref = someint; 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 } Ausgabe: intone: 5 reference: 5 intone: 7 reference: 7 91

93 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 } Ausgabe: intone: 5 reference: 5 &intone: 0x7fff5fbffa2c &reference: 0x7fff5fbffa2c Adressen der beiden Variablen sind identisch Referenzen werden bei Erzeugung initialisiert dienen nur als Synonyme für ihr Ziele 92

94 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 } Ausgabe: swap: 10, 5 main: 10, 5 mühsam durch ständiges Dereferenzieren Vorbereitungen für Aufruf nötig 93

95 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 } Ausgabe: swap: 10, 5 main: 10, 5 Syntax sehr viel direkter (leichter) genauso leistungsfähig keine Vorbereitungen in main nötig 94

96 Neuzuweisungen 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 } Ausgabe: x: 5 ref: 5 x: 8 y: 8 ref: 8 Referenz wirkt wirklich nur als Alias Neuzuweisung ist nicht möglich 95

97 Übersicht Referenzen Refenzen sind Synonyme für Variablen sehr leichte Syntax fast so leistungsfähig wie Zeiger Initialisierung mit (&) nicht mit Adressoperator verwechseln immer direkt initialisieren nicht versuchen Referenzen erneut zuzuweisen 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 } Syntax kann Programmablauf verschleiern bei Pointern ist immer klar was passiert 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

98 Vererbung 2 Polymorphie virtuelle Methoden abstrakte Klassen Mehrfachvererbung 97

99 Polymorphie jedes Objekt der abgeleiteten Klasse ist auch ein Objekt der Basisklasse Vererbung impliziert immer ist-ein-beziehung Jede Klasse definiert einen Datentyp Objekte können mehrere Typen haben abgeleitete Klassen haben mindestens zwei In C++ kann der jeweils passende Typ verwendet werden Diese Eigenschaft nennt man Polymorphie (griech. Vielgestaltigkeit) 98

100 in Code gegossen 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 }; und die Methode sortme: 1 void sortme(sortierverfahren &s) 2 { 3 s.sort(); 4 s.ausgabe(); 5 } sortme übernimmt Referenz auf Sortierverfahren 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

101 in Code gegossen - 2 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 } 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

102 Polymorphie- 2 BubbleSort redefiniert die Methode sort Nun ist BubbleSort auch ein Sortierverfahren folgende Anweisung macht Sinn Sortierverfahren *mysort = new BubbleSort(10); Bei Zeigern und Referenzen können alle Typen des jeweiligen Objektes verwendet werden intern wird Zeiger auf Sortierverfahren gespeichert zunächst einmal kann nur auf diese Methoden und Felder zugegriffen werden Frage: Was passiert bei Aufruf von mysort->sort()? Antwort: genau das Richtige! durch Einsatz virtueller Methoden V-table wird angelegt zur Laufzeit wird entsprechende Funktion aufgerufen 101

103 in Code gegossen - 3 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 } Ausgabe: aktuelle Sortierung: aktuelle Sortierung: (Zufallszahlen) Methode sortme kennt nur s (Referenz auf Sortierverfahren) Bei Aufruf von sort wird Einsprungstelle aus V-table gelesen es wird tatsächlich sort von BubbleSort aufgerufen Achtung: Klappt nur bei Zeigern und Referenzen 102

104 was es zu wissen gibt virtuelle Methoden erlauben Polymorphie abgeleitetes Objekt verhält sich wie Basisobjekt dies geschieht durch dynamische Bindung Methoden als virtuell deklarieren wenn sie polymorph verwendet werden sollen in diesem Fall auch virtueller Destruktor Objekt wird sonst evtl. nicht richtig bereinigt Konstruktoren können nicht virtuell sein in Java sind Methoden standardmäßig virtuell in C++ explizit durch Benutzer generell: Erzeugung von V-tables kostet Code wird dadurch langsamer virtual macht ohne Polymorphie keinen Sinn 103

105 Andere Aspekte der Polymorphie 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 Zugriff auch nicht sinnvoll zumindest programmiertechnisch unsauber Problem: was wenn man doch Zugriff braucht? Lösung: dynamic cast fortbewegungsmittel *A = new car(); car *mycar = dynamic cast <car *> (A); mycar->fahren(); gibt Nullpointer zurück wenn cast fehlschlägt nur bei polymorph verwendeten Objekten möglich es gibt auch noch andere casts: static cast const cast reinterpret cast 104

106 abstrakte Datentypen Die Methode sort von Sortierverfahren ist sinnlos bietet keinerlei Sortierung Objekte können in Wahrheit nicht sortieren überhaupt sind Objekte dieser Klasse sinfrei 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 105

107 Beispiel 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 }; abstrakte Methode in Zeile 9 Abstraktion durch =0 nach virtueller Methode 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 106

108 Beispiel 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 } InsertionSort redefiniert die AM sort alle AM müssen redefiniert werden 107

109 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 } 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 108

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

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

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