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

Transkript

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

2 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++ 2

3 Tutoren 4 Tutoren / 11 h pro Woche Sprechstunden auf der Kurswebseite Grundkurs C++ 3

4 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++ 4

5 Implementierung einer einfachen Klasse Quadrat - m_laenge: double + setlaenge(laenge: double) + getlaenge(): double Grundkurs C++ 5

6 //Quadrat.h #ifndef QUADRAT_H #define QUADRAT_H class Quadrat { Quadrat(); void setlaenge (double laenge); double getlaenge() const; // Konstruktor // Methode, nur Deklaration double m_laenge; #endif // Attribut Grundkurs C++ 6

7 //Quadrat.cpp #include Quadrat.h // Implementierung der Funktion setlaenge void Quadrat::setLaenge (double laenge) { m_laenge = laenge; double Quadrat::getLaenge() const { return m_laenge; Grundkurs C++ 7

8 //main.cpp #include Quadrat.h int main () { Quadrat meinquadrat; Quadrat* meinquadratzeiger; double laenge; // Quadratobjekt erstellen // Zeiger auf Quadratobjekt meinquadratzeiger = &meinquadrat; meinquadrat.setlaenge(25.0); laenge = meinquadratzeiger->getlaenge(); // Zeigeradresse setzen // Methode des Objekts aufrufen // Methode über Zeiger aufrufen return 0; Grundkurs C++ 8

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

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

11 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++ 11

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

13 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++ 13

14 new und delete //main.cpp #include Quadrat.h int main () { Quadrat meinquadrat; // Objekt auf Stack Quadrat* meinquadratdyn; meinquadratdyn = new Quadrat; // Zeiger auf Quadrat-Objekt // neues Objekt auf heap erstellen delete meinquadratdyn; // Quadrat-Objekt löschen, Speicher freigeben Grundkurs C++ 14

15 Konstruktor, Destruktor und this-zeiger class A { A (int c = 1000, int d = 2000) { this->c = c; this->d = d; // Konstruktor ~A(); // Destruktor void getzustand(); int c; int d; int main() { A neuesobjekt(); A neuesobjekct2(200, 300); Grundkurs C++ 15

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

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

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

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

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

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

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

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

24 Mehrfachvererbung class A { A(int x=1000, int y=2000): i(x), j(y) { cout << "A (constr.): i=" << i << ", j=" << j << "\n"; void getzustand() { cout << "A: i=" << i << ", j=" << j << "\n"; int i, j; class B : public A { B(int x=101, int y=102, int z=103): A(x, y), k(z) { cout << "B (constr.): "; getzustand(); int k; class C : public A { C(int x=201, int y=202, int z=203): A(x, y), l(z) { cout << "C (constr.): "; getzustand(); int l; Attribute der Klasse A 2x in D unveränderte Reihenfolge der Konstruktoraufrufe class D : public B, public C { D(int x=301, int y=302, int z=303): B(x, y), C(x+10,y+10), m(z){ int m; int main() { D instanz;

25 Mehrfachvererbung class A { A(int x=1000, int y=2000): i(x), j(y) { cout << "A (constr.): i=" << i << ", j=" << j << "\n"; void getzustand() { cout << "A: i=" << i << ", j=" << j << "\n"; int i, j; class B : virtual public A { B(int x=101, int y=102, int z=103): A(x, y), k(z) { cout << "B (constr.): "; getzustand(); int k; class C : virtual public A { C(int x=201, int y=202, int z=203): A(x, y), l(z) { cout << "C (constr.): "; getzustand(); int l; Attribute der Klasse A nur noch einmal in D! class D : public B, public C { D(int x=301, int y=302, int z=303): B(x, y), C(x+10,y+10), m(z){ int m; int main() { D instanz;

26 Konstruktoraufrufe bei virtuellen geerbten Klassen Reihenfolge der Konstruktoraufrufe: Konstruktoren der virtuellen (geerbten) Basisklasse(n) Konstruktoren der nicht-virtuellen Basisklasse(n) Konstruktoren der Elementobjekt-Klassen Konstruktoren der abgeleiteten Klasse Der Konstruktor der am weitesten abgeleiteten Klasse übernimmt die Initialisierung des virtuell geerbten Teiles der Klasse. Die anderen Aufrufe des Basisklassenkonstruktors der virtuell geerbten Klasse werden ignoriert. Grundkurs C++ 26

27 Zeiger auf die Basisklasse class Auto{ protected: int ps; int zylinder; Auto(int lei, int toepf) : ps(lei),zylinder(toepf){ void bremsen(){std::cout <<"BREMSE..." <<"\n"; class Cabrio : public Auto{ int offen; Cabrio(int lei, int toepf): Auto(lei,toepf),offen(0) { void dachauf(){ std::cout <<"AUF!" <<"\n"; offen = 1; void bremsen(){std::cout <<"BREMSE Cabrio..." <<"\n"; int main(){ Auto *z4 = new Cabrio(215,6); z4->bremsen(); ((Cabrio*)z4)->bremsen(); ((Cabrio*)z4)->dachAuf();

28 Zeiger auf die Basisklasse class Auto{ protected: int ps; int zylinder; Auto(int lei, int toepf) : ps(lei),zylinder(toepf){ void bremsen(){std::cout <<"BREMSE..." <<"\n"; class Cabrio : public Auto{ int offen; Cabrio(int lei, int toepf): Auto(lei,toepf),offen(0) { void dachauf(){ std::cout <<"AUF!" <<"\n"; offen = 1; void bremsen(){std::cout <<"BREMSE Cabrio..." <<"\n"; int main(){ Auto *z4 = new Cabrio(215,6); z4->bremsen(); ((Cabrio*)z4)->bremsen(); ((Cabrio*)z4)->dachAuf(); Ausgabe: BREMSE BREMSE Cabrio AUF!

29 Zugriff durch Basisklassenzeiger int main(){ Auto *parkpl[3] = {new Cabrio(215,6), new Lkw(600,16), new Jeep(400,12) Auto *auswahl = parkpl[i%3]; Jede Spezialisierung von Auto (Cabrio, Lkw, Jeep) habe eine eigene Methode bremsen() Ist der Zeiger vom Basistyp Auto wird die Methode von Auto aufgerufen, nicht die der Spezialisierungen. Grundkurs C++ 29

30 Polymorphismus class Auto{ virtual void bremsen(){std::cout <<"BREMSE..." <<"\n"; class Cabrio : public Auto{ void bremsen(){std::cout <<"BREMSE Cabrio..." <<"\n"; class Lkw : public Auto{ void bremsen(){std::cout <<"BREMSE LKW..." <<"\n"; Zeigt der Zeiger auswahl vom Typ Auto* auf ein abgeleitetes Objekt, so bestimmt nun beim Aufruf auswahl->bremsen() der Typ des Objekts, welche Variante von bremsen() zum Einsatz kommt. Dies geschieht zur Laufzeit ( late binding ). Destruktoren sollten immer virtuell angelegt werden! Grundkurs C++ 30

31 Polymorphismus II abstrakte Klassen class Auto{ virtual void bremsen()=0; class Cabrio : public Auto{ void bremsen(){std::cout <<"BREMSE Cabrio..." <<"\n"; class Lkw : public Auto{ void bremsen(){std::cout <<"BREMSE LKW..." <<"\n"; Die Klasse Auto kann nicht instanziiert werden Abstrakte Klassen können nicht als Typ für Funktionsparameter oder Rückgabewerte verwendet werden Abgeleitete Klassen müssen die rein virtuellen Methoden neu definieren, um instanziiert werden zu können. Grundkurs C++ 31

32 Überladen von Funktionen int wurzel (int i); float wurzel (float f); double wurzel (double f); void main () { int ia, ib; float fa, fb; ia = wurzel (ib); fa = wurzel (fb); Funktionen müssen sich in Anzahl und/oder Typ der Parameter unterscheiden, d.h. sie müssen eine andere Signatur aufweisen. Unterscheidung in Rückgabewert oder in den Namen der Parameter reicht nicht aus. Grundkurs C++ 32

33 Überladen von Funktionen II Bei Vererbung beachten: gleichnamige Methode in der abgeleiteten Klasse verdeckt alle gleichnamigen Methoden in der Basisklasse, unabhängig von der Signatur impliziter Aufruf von Basisklassenkonstruktor nur möglich, wenn ein Standardkonstruktor (Aufruf ohne Parameter) existiert virtuelle Methoden: Virtualität nur dann, wenn die Methode in der Basisklasse und der abgeleiteten Klasse dieselbe Signatur hat; ansonsten einfache Verdeckung Grundkurs C++ 33

34 Überladen von Funktionen Copy-Konstruktor class Quadrat { Quadrat ( double laenge ); Quadrat ( const Quadrat &q ); double m_laenge; char *bezeichnung; Quadrat::Quadrat ( const Quadrat &q ) { m_laenge = q.m_laenge; // Kopieren des Dateinamens bezeichnung = new char[strlen(q.bezeichnung) +1]; strcpy ( bezeichnung, q.bezeichnung ); Grundkurs C++ 34

35 Überladen von Operatoren class MeinString { char *inhalt; int laenge; void operator= ( const MeinString &zweiterstring ); int operator< ( const MeinString &zweiterstring ) const;... void MeinString::operator= ( const MeinString &zweiterstring ) { laenge = zweiterstring.laenge; delete [] inhalt; inhalt = new char [ laenge+1 ]; strcpy ( inhalt, zweiterstring.inhalt ); Grundkurs C++ 35

36 Templates: Funktionstemplates template <class T> T max (T a1, T a2) { if (a1 < a2) return a2; else return a1; kann auf beliebigen Datentypen/Klassen arbeiten nur eine Implementierung notwendig mehrere Platzhalter sind möglich (getrennt durch Kommata) konkrete Variante für bestimmten Datentyp wird erst erstellt, wenn die Funktion damit verwendet wird Trennung von Definition und Deklaration von daher nicht möglich Grundkurs C++ 36

37 Templates: Funktionstemplates template <class T> T max (T a1, T a2) { if (a1 < a2) return a2; else return a1; int main () { std::cout << max(3, 5); std::cout << max<int>(3, 5); kann auf beliebigen Datentypen/Klassen arbeiten nur eine Implementierung notwendig mehrere Platzhalter sind möglich (getrennt durch Kommata) konkrete Variante für bestimmten Datentyp wird erst erstellt, wenn die Funktion damit verwendet wird Trennung von Definition und Deklaration von daher nicht möglich Grundkurs C++ 37

38 Templates: Klassentemplates

39 Grundkurs C++ Buildsysteme

40 Buildsysteme Beispielhaftes Übersetzungsszenario: Verzeichnis tutorial7/ main.cpp, lcdrange.cpp, lcdrange.h *.cpp Kompilieren *.o *.h Grundkurs C++ 40

41 Headerdateien //blackbox.h #ifndef BLACKBOX_H #define BLACKBOX_H #include "port.h" class BlackBox{ BlackBox(); ~BlackBox(); char buf; void transfer(char &data); Port *inport; Port *outport; #endif //port.h #ifndef PORT_H #define PORT_H class Port{ Port(int id=0); int portnr; #endif Grundkurs C++ 41

42 Headerdateien II (funktioniert nicht!) //blackbox.h #ifndef BLACKBOX_H #define BLACKBOX_H #include "port.h" //port.h #ifndef PORT_H #define PORT_H #include "blackbox.h" class BlackBox{ BlackBox(); ~BlackBox(); char buf; void transfer(char &data); Port *inport; Port *outport; #endif class Port{ Port(int id=0); int portnr; BlackBox *mybb; BlackBox *rembb; #endif Grundkurs C++ 42

43 Headerdateien III //blackbox.h #ifndef BLACKBOX_H #define BLACKBOX_H #include "port.h" class Port; class BlackBox{ BlackBox(); ~BlackBox(); char buf; void transfer(char &data); Port *inport; Port *outport; #endif //port.h #ifndef PORT_H #define PORT_H #include "blackbox.h" class BlackBox; class Port{ Port(int id=0); int portnr; BlackBox *mybb; BlackBox *rembb; #endif Grundkurs C++ 43

44 Buildsysteme Build-Vorgang: Verzeichnis tutorial7/ main.cpp, lcdrange.cpp, lcdrange.h Compiler main.o, lcdrange.o *.o Linken prog Grundkurs C++ 44

45 Manueller Build-Vorgang Niemand will das von Hand machen! g++ -c -pipe -O2 -Wall -W -D_REENTRANT -DQT_NO_DEBUG -DQT_GUI_LIB - DQT_CORE_LIB -DQT_SHARED -I/usr/share/qt4/mkspecs/linux-g++ -I. - I/usr/include/qt4/QtCore -I/usr/include/qt4/QtGui -I/usr/include/qt4 -I. -I. -I. -o lcdrange.o lcdrange.cpp g++ -c -pipe -O2 -Wall -W -D_REENTRANT -DQT_NO_DEBUG -DQT_GUI_LIB - DQT_CORE_LIB -DQT_SHARED -I/usr/share/qt4/mkspecs/linux-g++ -I. - I/usr/include/qt4/QtCore -I/usr/include/qt4/QtGui -I/usr/include/qt4 -I. -I. -I. -o main.o main.cpp moc-qt4 -DQT_NO_DEBUG -DQT_GUI_LIB -DQT_CORE_LIB -DQT_SHARED - I/usr/share/qt4/mkspecs/linux-g++ -I. -I/usr/include/qt4/QtCore - I/usr/include/qt4/QtGui -I/usr/include/qt4 -I. -I. -I. lcdrange.h -o moc_lcdrange.cpp g++ -c -pipe -O2 -Wall -W -D_REENTRANT -DQT_NO_DEBUG -DQT_GUI_LIB - DQT_CORE_LIB -DQT_SHARED -I/usr/share/qt4/mkspecs/linux-g++ -I. - I/usr/include/qt4/QtCore -I/usr/include/qt4/QtGui -I/usr/include/qt4 -I. -I. -I. -o moc_lcdrange.o moc_lcdrange.cpp g++ -Wl,-O1 -o tutorial7 lcdrange.o main.o moc_lcdrange.o -lpthread -L/usr/lib -lqtgui -lqtcore Grundkurs C++ 45

46 make Compilieren und Linken wird von make automatisiert. Informationen zu Quelltextdateien und Libraries steht in Makefiles. Buildvorgang: Aufruf von make Grundkurs C++ 46

47 qmake Qt-spezifische Erweiterungen (z.b. QObject, signals, slots). Standard-C++-Compiler kennt diese Erweiterungen nicht. Meta Object Compiler (moc) erzeugt Standard-C++ Dateien. Viele Einzelschritte Außerdem: User Interface Compiler (uic): QtDesigner Vereinfachung durch Verwendung eines Buildsystems: qmake Grundkurs C++ 47

48 qmake qmake project qmake make (Projektdatei *.pro erzeugen) (Makefile(s) erzeugen) (mocen, kompilieren, linken) qmake wird nur aufgerufen, wenn Dateien hinzukommen bzw. entfernt werden. Bei Problemen *.pro bearbeiten, nicht aber die Makefiles Grundkurs C++ 48

49 qmake beispielhafte *.pro Datei HEADERS += port.h \ blackbox.h SOURCES += build.cpp \ port.cpp \ blackbox.cpp TARGET=../bin/build Grundkurs C++ 49

50 Hausaufgabe heute Abend auf Abgabetermin: 06. Mai 2015, 15:00 Uhr per an: Grundkurs C++ 54