Lehrstuhl für Datenverarbeitung. Technische Universität München. Grundkurs C++

Transkript

1 Grundkurs C++ IDE Implementierung von Klassenhierarchien Compiler, Linker Buildsysteme

2 Tim Habigt Büro Z949 Julian Habigt Büro Z941 Grundkurs C++ 2

3 Warum C++? Sprache Rechenzeit Memory KB C++ GNU g++ 5, Java 6 26, Python 3 27, C# Mono 96, Software: regex-dna, Debian Computer Language Shootout Grundkurs C++ 3

4 Warum C++? Grundkurs C++ 4

5 Warum C++? Strenge Standardisierung von Beginn an (ca. 1985) Extrem schnelle und effiziente Compiler Wird immer noch weiterentwickelt C++11 seit August 2011 standardisiert Große Vielfalt an Compilern für die allermeisten Plattformen Viele Entwicklungstools verfügbar Grundkurs C++ 5

6 Das Ziel Entwicklung eines Spiels Teamarbeit in Teams aus 5 Personen Grundkurs C++ 6

7 Das Ziel Entwicklung eines Spiels Teamarbeit in Teams aus 5 Personen Roboter erst im Leistungskurs, sorry Grundkurs C++ 7

8 Zeitplan Vorlesung Entfällt Vorlesung, Gruppeneinteilung Vorlesung Vorprojekt Vorlesung und Präsentation Analyse- & Designmodell und Working Sessions und Abschlusspräsentation Show & Tell Grundkurs C++ 8

9 Inhalte Objektorientierung Implementierung von Klassen Entwicklungsumgebung (IDE) Compiler, Linker Grafische Oberflächen (Qt) Ausnahmebehandlung Versionsverwaltung Analyse und Design Debugging Grundkurs C++ 9

10 Bewertung Eine Hausaufgabe (ca. 10%) Vorprojekt (ca. 15%) Designmodell und Pflichtenheft (ca. 10%) Abschlusspräsentation (ca. 10%) Hauptprojekt (ca. 50%) Dokumentation (ca. 5%) Grundkurs C++ 10

11 Nützliches LDV-Webseite zum Kurs Hausaufgaben Vorlesungsfolien Skript C++ Buch Thinking in C++ 2 Tutoren, die euch bei sämtlichen Fragen und Problemen weiterhelfen werden cpp-tutor@ldv.ei.tum.de Praktikumsraum Grundkurs C++ 11

12 IDE Integrated Development Environment Wir empfehlen: Qt Creator (Bestandteil des Qt SDK) Download unter : Bei Problemen: Bitte nicht zögern, die Tutoren zu fragen! Ausführliche Dokumentation unter Grundkurs C++ 12

13 Tutoren 2 Tutoren / 10 h pro Woche Sprechstunden auf der Kurswebseite Grundkurs C++ 13

14 Motivation Realität ist objektorientiert Vereinfachung und Kapselung Wiederverwendbarkeit Leichte Erweiterbarkeit Parallelisierbarer Entwicklungsprozess Grundkurs C++ 14

15 Aufbau und Eigenschaften eines Objekts von Außen Objekt hat öffentliche Eigenschaften (Attribute) Objekt besitzt öffentlich definierte Funktionen (Methoden), welche sich auf seine Eigenschaften auswirken von Innen Verarbeiten der über Funktionsaufrufe eingehenden Befehle (Botschaft) zur Änderungen der Eigenschaften Interne Funktionen und Eigenschaften, zur Wahrnehmung der äußeren Funktion Grundkurs C++ 15

16 Aufbau und Eigenschaften des Objekts Auto von Außen zugänglich Attribut Geschwindigkeit (nur lesend) Methoden beschleunigen und bremsen definierte Funktionsweise Aufruf der Methoden verändert die Geschwindigkeit von Innen Wird beschleunigen aufgerufen, mehr Kraftstoff an den Motor liefern Wird bremsen aufgerufen, Bremsanlage betätigen Grundkurs C++ 16

17 Folgen dieses Aufbaus für das Objekt Auto Für den externen Benutzer von Auto ist es vollkommen egal was passiert wenn er beschleunigen möchte Jedes Auto -Objekt MUSS die Methode beschleunigen und bremsen verstehen Der Aufruf der Methode beschleunigen ist von der konkreten Implementierung von Auto vollkommen unabhängig Auto -Objekte können innerhalb des Programms beliebig ausgetauscht werden Grundkurs C++ 17

18 Begriffe: Objekt Klasse Instanz Bei der Arbeit mit Objekten unterscheidet man: Klasse Zusammenfassung von ähnlichen Objekten, welche sich nur in Ihren Attributen unterscheiden Charakterisiert die Objekte Schablone / Prototyp Instanz Konkretes Objekt das bestimmte Attributwerte aufweist Grundkurs C++ 18

19 Beispiel: Objekt Klasse Instanz Klasse Auto Attribute: Geschwindigkeit Methoden: beschleunigen bremsen Julians Auto Attribute: Geschwindigkeit =50,4 Methoden: beschleunigen bremsen Instanzen Tims Auto Attribute: Geschwindigkeit=62,7 Methoden: beschleunigen bremsen Grundkurs C++ 19

20 Implementierung einer einfachen Klasse Auto - m_geschwindigkeit: double + beschleunigen() + bremsen() + getspeed(): double Grundkurs C++ 20

21 Namensbereiche (namespaces) Vermeidung von Mehrdeutigkeiten Klassen und Variablen werden zu logischen Paketen zusammengefasst Deklaration/Erweiterung an verschiedenen Stellen in mehreren Dateien möglich namespace mynamespace{} Einbinden eines Namenbereichs ist global, innerhalb eines Namensbereichs, innerhalb einer Funktion möglich using namespace mynamespace; Einbeziehen einzelner Bestandteile eines Namensbereichs mit Bereichszugriffsoperator möglich mynamespace::fkt1(); Einbinden eines einzelnen Elements: using namespace mynamespace::fkt1(); Grundkurs C++ 21

22 //Auto.h #ifndef AUTO_H #define AUTO_H class Auto { public: void beschleunigen(); void bremsen(); double getspeed(); // Methode, nur Deklaration private: double m_geschwindigkeit; }; #endif // Attribut Grundkurs C++ 22

23 //Auto.cpp #include Auto.h // Implementierung der Methode beschleunigen void Auto::beschleunigen() { m_geschwindigkeit += 10.0; } void Auto::bremsen() { m_geschwindigkeit -= 10.0; } double Auto::getSpeed() { return m_geschwindigkeit; } Grundkurs C++ 23

24 //main.cpp #include Auto.h int main () { Auto meinauto; double geschwindigkeit; // Autoobjekt erstellen meinauto.beschleunigen(); geschwindigkeit = meinauto.getspeed(); // Methode des Objekts aufrufen // Geschwindigkeit auslesen } return 0; Grundkurs C++ 24

25 //main.cpp #include Auto.h int main () { Auto meinauto; Auto* meinautozeiger; double geschwindigkeit; // Autoobjekt erstellen // Zeiger auf Autoobjekt meinautozeiger = &meinauto; meinautozeiger->beschleunigen(); geschwindigkeit = meinautozeiger->getspeed(); // Zeigeradresse setzen // Methode des Objekts aufrufen // Methode über Zeiger aufrufen } return 0; Grundkurs C++ 25

26 Generalisierung / Vererbung Vererbung ermöglicht Gruppen von Klassen, die sich ähnlich sind, aber Unterschiede haben Gemeinsame Attribute und Methoden werden in der Elternklasse definiert Verschiedene Kinder erben diese und implementieren weitere Methoden und Attribute Jedes Kind kann auch die Methoden und Attribute der Eltern überschreiben, also neu implementieren Grundkurs C++ 26

27 Beispiel: Vererbung Auto Geschwindigkeit beschleunigen() bremsen() Cabrio Geschwindigkeit VerdeckOffen beschleunigen() bremsen() verdecköffnen() LKW Geschwindigkeit Anhänger beschleunigen() bremsen() Rot: geerbte Attribute/Methoden Blau: überschriebene Methoden Grundkurs C++ 27

28 Objektbeziehungen Wesentliches Merkmal der objektorientierten Programmierung ist die Interaktion der Objekte Objekte stehen in Beziehungen zueinander Es gibt verschiedene Arten von Beziehungen Komposition Aggregation Assoziation Grundkurs C++ 28

29 Objektbeziehungen Komposition Teile existieren nur gemeinsam Aggregation Teile bilden eine Einheit Können auch alleine existieren Assoziation Teile agieren gemeinsam: flüchtige Bindung Unternehmen Abteilung Mitarbeiter Komposition ist Teil von Assoziation interagiert mit Aggregation ist enthalten in Kunde Grundkurs C++ 29

30 Erwartungen an das objektorientierte Paradigma Wiederverwendbarkeit Erweiterbarkeit Leichte Wartbarkeit Wodurch? Klasse hat definiertes Verhalten wegen Kapselung Die Attribute, und damit die Daten der Klasse sind nicht beliebig änderbar. Grundkurs C++ 30

31 Realisierung der Kapselung Der Zugriff auf Attribute des Objekts muss geregelt werden Methoden dienen zur Abarbeitung von Botschaften Methoden sind also die Schnittstelle zu den Daten des Objekts Auto Geschwindigkeit beschleunigen() bremsen() Cabrio VerdeckOffen verdecköffnen() LKW Anhänger bremsen() Es sind folgende Fragen zu klären: Welche Methode darf welche Daten ändern? Wer darf die Methoden aufrufen? Grundkurs C++ 31

32 Realisierung der Kapselung Auto Cabrio VerdeckOffen verdecköffnen() Geschwindigkeit Klasse besteht aus: beschleunigen() bremsen() LKW Anhänger bremsen() Attributen und Methoden der Basisklasse Eigenen Attributen und Methoden Zugriffsregelung sollte auf Vererbung aufsetzen! Grundkurs C++ 32

33 Public Manche Daten sind jedem zugänglich, also allen Methoden jeglicher Klassen Beispiel: Luftdruck (durch Methoden luftdruckerhoehen(), luftdruckerniedrigen(), Attribut Luftdruck) + Luftdruck Auto + luftdruckerhoehen() + luftdruckerniedrigen() + public- Attribut/Methode Grundkurs C++ 33

34 Private Auf manche Daten können nur die Methoden der Klasse zugreifen Beispiel: Geschwindigkeit (durch Methoden bremsen(), beschleunigen()) Auto - Geschwindigkeit + bremsen() + beschleunigen() + public- Attribut/Methode - private- Attribut/Methode Grundkurs C++ 34

35 Protected Auf manche Daten können nur die Methoden der Klasse zugreifen, sowie die Methoden der Klassen, die von dieser erben Beispiel: InnenraumTemperatur (durch Methoden der abgeleiteten Klasse heizen(), kühlen()) Auto Cabrio # InnenraumTemperatur + heizen() + kühlen() + public # protected - private Grundkurs C++ 35

36 Überblick Auto + Luftdruck # innenraumtemperatur - Geschwindigkeit + bremsen() + beschleunigen() + luftdruckerhoehen() + luftdruckerniedrigen() + public- Attribut/Methode # protected Attrib./Meth. - private- Attribut/Methode Grundkurs C++ 36

37 Private und protected Methoden Auto + Luftdruck # InnenraumTemperatur - Geschwindigkeit Cabrio + beschleunigen() + luftdruckerhoehen() + luftdruckerniedrigen() # alarmauslösen() - benzinpumpen() + heizen() + kühlen() + public- Attribut/Methode # protected Attrib./Meth. - private- Attribut/Methode Grundkurs C++ 37

38 Public Attribute <-> Kapselung Attribute, die durch jeden also alle Methoden änderbar sind! Auto + Anzahl der Kratzer + Tankinhalt Keine Kapselung! Art der Zugriffe völlig unbestimmt! Grundkurs C++ 38

39 Public Attribute <-> Kapselung II Immer besser: Methoden zum Setzen und Auslesen der Attribute Aber: nur wo nötig und sinnvoll, da die Kapselung sonst aufgeweicht wird Auto - Anzahl der Kratzer - Tankinhalt + gettankinhalt() + settankinhalt() Das Verhalten kann definiert werden, d.h. Bereichsüberwachung ist beispielsweise möglich Fehlersuche und Wartung wird enorm vereinfacht Grundkurs C++ 39

40 Zugriffsregelung und Vererbung Quadrat - m_laenge : double Rechteck - m_breite : double + setlaenge (laenge: double) + getlaenge () : double + setbreite (breite: double) + getbreite () : double Grundkurs C++ 40

41 Zugriffsregelung und Vererbung class Quadrat { public: void setlaenge(double laenge); // Methode, nur Deklaration double getlaenge() { return m_laenge; } // Methode mit Definition private: int m_laenge; // Attribut }; class Rechteck : public Quadrat { // Vererbung der Klasse Quadrat public: void setbreite(double breite); double getbreite () { return m_breite; } private: double m_breite; }; Grundkurs C++ 41

42 Zugriffsregelungen bei Ableitung: public AK : public BK{ } Basisklasse public abgeleitete Klasse public protected protected private private * *Zugriff kann nur über Methoden der Basisklasse erfolgen! Grundkurs C++ 42

43 Zugriffsregelungen bei Ableitung: protected AK : protected BK{ } Basisklasse public abgeleitete Klasse protected protected protected private private * *Zugriff kann nur über Methoden der Basisklasse erfolgen! Grundkurs C++ 43

44 Zugriffsregelungen bei Ableitung: private AK : private BK{ } Basisklasse public AK : BK{ } abgeleitete Klasse private protected private private private * *Zugriff kann nur über Methoden der Basisklasse erfolgen! Grundkurs C++ 44

45 Speicherverwaltung in C++ Stack //main.cpp #include Auto.h int main () { Auto meinauto; // Objekt wird auf Stack angelegt } // Wenn die Methode terminiert, werden Stack-Objekte gelöscht Grundkurs C++ 45

46 Speicherverwaltung in C++ Heap, new und delete //main.cpp #include Auto.h int main () { Auto* meinautodyn; meinautodyn = new Auto; // Zeiger auf Quadrat-Objekt // neues Objekt auf heap erstellen } delete meinautodyn; // Auto-Objekt löschen, Speicher freigeben Grundkurs C++ 46

47 Konstruktor, Destruktor und this-zeiger class A { public: A () { c = 10; } // Konstruktor ~A(); // Destruktor void getzustand(); private: int c; }; int main() { A neuesobjekt(); } Grundkurs C++ 47

48 Konstruktor, Destruktor und this-zeiger class A { public: A (int c = 1000, int d = 2000) { this->c = c; this->d = d;} // Konstruktor ~A(); // Destruktor void getzustand(); private: }; int c; int d; int main() { A neuesobjekt(); A neuesobjekt2(200, 300); } Grundkurs C++ 48

49 //Auto.h #ifndef AUTO_H #define AUTO_H class Auto { public: Auto(); ~Auto(); void beschleunigen(); void bremsen(); double getspeed(); // Konstruktor // Destruktor // Methode, nur Deklaration private: double m_geschwindigkeit; }; #endif // Attribut Grundkurs C++ 49

50 //Auto.cpp #include Auto.h Auto::Auto() { m_geschwindigkeit = 0; } Auto::~Auto() { } void Auto::beschleunigen() { m_geschwindigkeit += 10.0; } void Auto::bremsen() { m_geschwindigkeit -= 10.0; } double Auto::getSpeed(){ return m_geschwindigkeit;} Grundkurs C++ 50

51 Initialisierungslisten class A { public: A (int k = 1000, int l = 2000) : c(k), d(l) { } void getzustand(); private: int c; int d; } Grundkurs C++ 51

52 Konstruktor und Ableitung class A { public: A (int k=1, int l=2) : c(k), d(l){std::cout << A! << \n ;} private: int c; int d; } class B : A { public: B (int m=3) : e(m){std::cout << B! << \n ;} private: int e; } int main{ } B b; Grundkurs C++ 52

53 Konstruktor und Ableitung class A { public: A (int k=1, int l=2) : c(k), d(l){std::cout << A! << \n ;} private: int c; int d; } class B : A { public: B (int m=3) : e(m){std::cout << B! << \n ;} private: int e; } Ausgabe: int main{ } B b; A! B! Abgeleitete Klasse ruft Standardkonstruktor der Basisklasse auf! Grundkurs C++ 53

54 Aufrufreihenfolge von Konstruktoren Konstruktoren der Basisklassen(n) Konstruktoren der Elementobjekt-Klassen Konstruktoren der abgeleiteten Klasse Grundkurs C++ 54

55 Initialisierungslisten II class A { public: A (int k=1, int l=2) : c(k), d(l){std::cout << A! << \n ;} private: int c; int d; } class B : A { public: B (int m=3,int n=6,int o=9) : A(n,o),e(m){std::cout << B! << \n ;} private: int e; expliziter Aufruf des Konstruktors der Basisklasse } Reihenfolge bleibt unverändert Grundkurs C++ 55

56 Verdeckung class A { protected: int c; int d; public: A() : c(1),d(2){} void getzustand(){std::cout <<"A: " << c <<" "<< d <<"\n";} }; class B : A { private: int d; public: B(): d(3) {} void getzustand(){std::cout <<"B: " << c <<" "<< d <<"\n";} }; int main(){ B b; b.getzustand(); }

57 Verdeckung class A { protected: int c; int d; public: A() : c(1),d(2){} void getzustand(){std::cout <<"A: " << c <<" "<< d <<"\n";} }; class B : A { private: int d; public: B(): d(3) {} void getzustand(){std::cout <<"B: " << c <<" "<< d <<"\n";} }; int main(){ B b; b.getzustand(); } Ausgabe: B: 1 3

58 Bereichszugriffsoperator class A { protected: int c; int d; public: A() : c(1),d(2){} void getzustand(){std::cout <<"A: " << c <<" "<< d <<"\n";} }; class B : A { private: int d; public: B(): d(3) {} void getzustand(){std::cout <<"B: " << c <<" "<< A::d <<"\n";} }; int main(){ B b; b.getzustand(); } Ausgabe: B: 1 2

59 Mehrfachvererbung class A { public: A(int x=1000, int y=2000):i(x),j(y){} void getzustand(); private: int i; int j; }; class B : public A { public: B(int x, int y=102, int z=103) : A(111, 112), k(z) {} void getzustand(); private: int k; }; class C : public A{ public: C(int x, int y=201, int z=202) : A(211, 212), l(z) {} private: int l; void getzustand(); }; Attribute der Klasse A 2x in D unveränderte Reihenfolge der Konstruktoraufrufe class D : public B, public C{ public: D(int x=201, int y=202, int z=203) : B(311, 312), C(321,322), m(z){} void getzustand(); private: int m; };

60 Mehrfachvererbung class A { public: A(int x=1000, int y=2000):i(x),j(y){} void getzustand(); private: int i; int j; }; class B : virtual public A { public: B(int x, int y=102, int z=103) : A(111, 112), k(z) {} void getzustand(); private: int k; }; class C : virtual public A{ public: C(int x, int y=201, z=202) : A(211, 212), l(z) {} private: int l; void getzustand(); }; Attribute der Klasse A nur noch einmal in D! class D : public B, public C{ public: D(int x=201, int y=202, int z=203) : B(311, 312), C(321,322), m(z){} void getzustand(); private: int m; };

61 Hausaufgabe heute Abend auf Abgabetermin: 8. Mai 2013, 15:00 Uhr per an Grundkurs C++ 88