Software Entwicklung Praktikum [SEP] - arcustan.com Praktikum/SEP...[SEP] Ausarbeitung 2 Ausarbeitung aus dem VO-Stoff, erhebt keinerlei Anspruch auf Vollständigkeit oder Korrektheit

Datum: 6. Juni 2009 Rev: 00 Autor: Christian L.

Theorie-Fragenkatalog

Software Entwicklung Praktikum [SEP]

[SEP] Ausarbeitung 2

Ausarbeitung aus dem VO-Stoff, erhebt keinerlei Anspruch auf Vollständigkeit oder Korrektheit.

WICHTIG diese Ausarbeitung bezieht sich auf die VO Folien. Ich habe einfach mögliche Fragen mir selbst zusammen

gereimt. Wobei aber auch die Fragen aus den vergangen Prüfungen dabei sind.

MFG Chris

[SEP] Ausarbeitung Inhaltsverzeichnis

3

Inhaltvz.

1 Inhaltsverzeichnis

1111 InhaltsverzeichnisInhaltsverzeichnisInhaltsverzeichnisInhaltsverzeichnis ........................................................................................................................................................................................................................................................................................................................................................................................................................................................................ 3333

2222 Kaptitel #1Kaptitel #1Kaptitel #1Kaptitel #1 .................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................... 6666

2.1 Was sind Attribute, Objekte, Methoden, Instanzen, Klassen .................................................................................................. 6

2.2 Arten von Assoziationen ............................................................... 7

2.3 Was bedeutet Kapselung ............................................................... 7

2.4 Welche Eigenschaften könne Members einer Klassen besitzen ................................................................................................. 7

2.5 Wann sollte Vererbung nicht angewandt werden ............. 8

2.6 Was bezeichnet man als Vererbung ......................................... 8

2.7 Was bedeutet Mehrfachvererbung: .......................................... 9

2.8 Erklären Sie Polymorphie ............................................................. 9

2.9 Was sind virtuelle Methoden ................................................... 10

2.10 Rein Virtuelle (=abstrakte) Methoden ................................ 10

3333 Kapitel #2Kapitel #2Kapitel #2Kapitel #2----3333 ............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................ 11111111

3.1 gcc Befehle ........................................................................................ 11

3.2 Namespaces ..................................................................................... 11

3.3 Eigenschaften des Datentyps bool ......................................... 11

3.4 Eigenschaften des Datentyps const ....................................... 12

3.5 Welchen Vorteil hat die Variablen-Definition in condition ............................................................................................ 13

3.6 Erklären Sie Overloading ........................................................... 13

3.7 Erklären Sie Overriting ............................................................... 13

3.8 Wie setzt sich die Signatur einer Methode zusammen . 13

3.9 Default Parameter ......................................................................... 13

3.10 Erklären Sie Funktionen mit dem Schlüsselwort „inline“................................................................................................................ 14

3.11 Was wissen Sie über die Sichtbarkeit von Klassen Attributen u Methoden................................................................ 14

3.12 Welche Möglichkeiten gibt es Methoden zu implementieren .............................................................................. 14

3.13 Besitzen Konstruktoren einen Rückgabewert .................. 14

3.14 Was wissen sie über den Copy Konstruktor ...................... 15

3.15 Was wissen sie über den Default Konstruktor ................. 15

3.16 Was wissen sie über den Destuktor ...................................... 16

3.17 Erklären Sie ihnen alle bekannten Speicherklassen ...... 16

3.18 Was und warum geschieht bei der globale /statischer Def. von Variablen/Arrays ......................................................... 16

3.19 Was wissen Sie über Klassen Attribute/Methoden ........ 16

3.20 Welche Möglichkeiten gibt es Klassen Attribute Konstant zu machen ..................................................................... 17

3.21 Warum sollte ein virtueller Destuktor verwendet werden ............................................................................................... 17


4

Inhaltvz.

4444 Kapitel #4Kapitel #4Kapitel #4Kapitel #4 ............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................ 18181818

4.1 Was sind Abstrakte Klassen ...................................................... 18

4.2 Was versteht man unter static_cast<>() ........................... 18

4.3 Was versteht man unter dynamic_cast<>() ..................... 18

4.4 Was versteht man unter reinterpret_cast<>() ............... 19

4.5 Was versteht man unter const_cast<>() ........................... 19


5.1 Syntax Exceptiones ....................................................................... 20

5.2 Was passiert wenn eine Exception geworfen wird ........ 20

5.3 Was ist bei Exception generell zu beachten ....................... 20

5.4 Was passiert wenn eine Methode eine andere Exception wirft als in der Deklaration definiert .................................... 21

5.5 Funktionen mit/ohne Exceptions .......................................... 21

5.6 Auf was, ist bei SELBST def. Exception Klassen zu achten................................................................................................................ 21

5.7 Was passiert, wenn im Konstruktor eine Exception geworfen wird ................................................................................. 21

5.8 Was passiert, wenn im Destuktor eine Exception geworfen wird ................................................................................. 21


6.1 Wobei hilft das Schlüsselwort friend .................................... 22

6.2 Wann sollte der Zuweisungsoperator public gesetzt werden wann nicht ....................................................................... 22

6.3 Welches Problem muss beim Zuweisungsoperator ....... 22

6.4 Welches Problem entsteht beim << operator ................ 22

6.5 Wie kann der <<operator „virtuell“ gemacht werden . 22


7.1 Beschreiben Sie das Diamond Problem:.............................. 23

7.2 Wie wird das Diamond Problem gelöst ............................... 23

7.3 Welche Besonderheiten ergeben sich durch Mehrfachvererbung ...................................................................... 24

7.4 Vorteil von templates .................................................................. 24

7.5 Welche Arten von templates kennen Sie ............................ 24

7.6 Worauf muss bei Klassentemplates geachtet werden .. 24

7.7 Nennen Sie ein Beispiel für ein Funktionstemplate ....... 24


8.1 Was heißt STL ................................................................................. 25

8.2 Welche Vorteile hat ein Auto-Pointer................................... 25

8.3 Was passiert bei einer Kopie eines Auto-Pointer............ 25

8.4 Welche Vorteile bieten Streams .............................................. 25

8.5 Was ist ein Vektor und welche Eigenschaften besitzt er................................................................................................................ 25

8.6 Was sind Iteratoren ...................................................................... 26

8.7 Welche Arten von Container kennen Sie............................. 26


5

Inhaltvz.

8.8 Container – Adapter ..................................................................... 27

8.9 Algorithmen ..................................................................................... 27

ImpressumImpressumImpressumImpressum ........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................ 28282828

[SEP] Ausarbeitung Kaptitel #1

Fragen

6

2 Kaptitel #1

2.12.12.12.1 Was sind Attribute, Objekte, Methoden, Instanzen, KlassenWas sind Attribute, Objekte, Methoden, Instanzen, KlassenWas sind Attribute, Objekte, Methoden, Instanzen, KlassenWas sind Attribute, Objekte, Methoden, Instanzen, Klassen

� Klassen:Klassen:Klassen:Klassen:

Zusammengehörige Attribute (Daten) und Methoden (Funktionen) werden in Klassen zusammengefasst.

Jede Klasse besitzt zugleich ihren eigenen Namespace. Der dem Namen der Klasse entspricht. z.B: class A, A::methode(…){}

� Objekte:Objekte:Objekte:Objekte:

Objekte sind konkrete Instanzen einer Klasse.

z.B: Student s1; oder Faklultät.

� Attribute, Methoden:Attribute, Methoden:Attribute, Methoden:Attribute, Methoden:


Fragen

7

2.22.22.22.2 Arten von Assoziationen Arten von Assoziationen Arten von Assoziationen Arten von Assoziationen

Generalisierung ("A ist-ein B") auch Vererbung

Komposition ("A ist-ein-Teil-von B")

Assoziation (Pfeil und Beschreibung optional)

� MächtigkeitMächtigkeitMächtigkeitMächtigkeit

Sollte auf beiden Seiten im Klassendiagramm angegeben werden.

z.B:

2.32.32.32.3 Was bedeutet KapselungWas bedeutet KapselungWas bedeutet KapselungWas bedeutet Kapselung

"Geheimnisprinzip" (information hiding).

Im Allgemeinen sind die Attribute eines Objektes von außen nicht sichtbar (private).

Zugriff erfolgt ausschließlich über öffentliche Methoden. Es gibt auch "geheime" Methoden.

2.42.42.42.4 Welche Eigenschaften könne Members einer Klassen besitzenWelche Eigenschaften könne Members einer Klassen besitzenWelche Eigenschaften könne Members einer Klassen besitzenWelche Eigenschaften könne Members einer Klassen besitzen

---- private

++++ public

~~~~ package (friend)

#### protected


Fragen

8

2.52.52.52.5 Wann sollte Vererbung nicht angewandt werdenWann sollte Vererbung nicht angewandt werdenWann sollte Vererbung nicht angewandt werdenWann sollte Vererbung nicht angewandt werden

Für den Fall "B ist-ähnlich-wie A".

2.62.62.62.6 Was bezeichnet man als VererbungWas bezeichnet man als VererbungWas bezeichnet man als VererbungWas bezeichnet man als Vererbung

Oft sind Klassen recht ähnlich (haben dieselben Attribute und/oder Methoden).

Um nicht den selben Coden für eine abgeleitete Klassen nochmal implementieren zu müssen gibt es das Prinzip der Vererbung in C++:

Eine Klasse B (subclass) kann Attribute und Methoden von einer anderen Klasse A (superclass) "erben". Man sagt auch: B "ist-ein" A

� Klassendiagramm Symbol:Klassendiagramm Symbol:Klassendiagramm Symbol:Klassendiagramm Symbol:

� Source Code:Source Code:Source Code:Source Code:

Class B: public Class A {…}

� Konstruktor:Konstruktor:Konstruktor:Konstruktor:

Class B(membersA, members): A(membersA), members_(members) {…}

� Möglichkeiten für Vererbung Bsp.:Möglichkeiten für Vererbung Bsp.:Möglichkeiten für Vererbung Bsp.:Möglichkeiten für Vererbung Bsp.:

class A { public: int x; };

class B : private A { ... }

nur B kann auf x zugreifen (default!)

class B : public A { ... }

x ist auch in B public (normalerweise will man das!)

class B : protected A { ... }

nur B und davon abgeleitetet Klassen können auf x zugreifen


Fragen

9

2.72.72.72.7 Was bedeutet Mehrfachvererbung:Was bedeutet Mehrfachvererbung:Was bedeutet Mehrfachvererbung:Was bedeutet Mehrfachvererbung:

Klassen können auch von mehreren Basisklassen abgeleitet werden, und erben damit alle deren Eigenschaften.

� Source Code MIT Diamond Problem:Source Code MIT Diamond Problem:Source Code MIT Diamond Problem:Source Code MIT Diamond Problem:

Class Student : public Person Class Professor : public Person Class PhDstudent : public Student, public Professor

� Source Code Source Code Source Code Source Code OHNEOHNEOHNEOHNE Diamond Problem:Diamond Problem:Diamond Problem:Diamond Problem:

Class Student : virtual public Person Class Professor : virtual public Person Class PhDstudent : public Student, public Professor

� KonstruktorKonstruktorKonstruktorKonstruktor::::

PhDstudent(membersPerson, membersStudent, membersPr of, members) : Person (membersPerson), Student (membersPerson,membersStudent), Professor (membersPerson, membersProf), members_(members) {…}

2.82.82.82.8 Erklären Sie PolymorphieErklären Sie PolymorphieErklären Sie PolymorphieErklären Sie Polymorphie

Instanzen von abgeleiteten Klassen können auch als Instanzen der Basisklasse verwendet werden

z.B.: In einer Liste von Person-Objekten können Objekte vom Typ Professor, Student, PhDStudent auftauchen.


Fragen

10

2.92.92.92.9 Was sind Was sind Was sind Was sind vvvvirtuelle Methodenirtuelle Methodenirtuelle Methodenirtuelle Methoden

Bei einer virtuellen Methode wird die Entscheidung, welche konkrete Implementation der Methode aufgerufen wird, bis zur Laufzeit aufgeschoben ("late binding").

Der Compiler erzeugt automatisch eine interne Tabelle (V-Table) und Code, der zur Laufzeit den Typ des Objekts ermittelt und die richtige Funktion aufruft.

2.102.102.102.10 Rein Virtuelle (=abstrakte) MetRein Virtuelle (=abstrakte) MetRein Virtuelle (=abstrakte) MetRein Virtuelle (=abstrakte) Methodenhodenhodenhoden

Manchmal soll bzw. kann soll bzw. kann soll bzw. kann soll bzw. kann eine Methode in der Basisklasse gar nicht implementiert werden, sondern nur in den Subklassen (= rein virtuelle Methode)

Eine abstrakte Klasse hat zumindestzumindestzumindestzumindest eineeineeineeine solche rein virtuelle Methode (keine Objekte dieses Typs können existieren).

Eine konkrete Subklasse muss alle rein virtuellen Methodenmuss alle rein virtuellen Methodenmuss alle rein virtuellen Methodenmuss alle rein virtuellen Methoden implementieren (nur dann können solche Objekte erzeugt werden).

� Syntax:Syntax:Syntax:Syntax:

virtual <method-declaration> = 0;

[SEP] Ausarbeitung Kapitel #2-3

Fragen

11

3 Kapitel #2-3

3.13.13.13.1 gcc Bgcc Bgcc Bgcc Befehleefehleefehleefehle

----fnofnofnofno----strengthstrengthstrengthstrength----reducereducereducereduce keine Schleifenoptimierungen zulassen ----IIII Pfad für die Headerdateien (include) ----LLLL Pfad für die Programmbibliotheken ----llll bindet zusätzliche Programm-Bibliotheken (Libraries) ein ----oooo der nachfolgende Name soll als Programmname verwendet werden ----O2O2O2O2 weist den Compiler an, den Code weiter zu optimieren ----pgpgpgpg Informationen für gprof (Profiler) erzeugen ----pipepipepipepipe Linux-Pipes zum Datenaustausch zwischen Compilerstufen verwenden ----wallwallwallwall weist den Compiler an, alle auftretenden Warnungen anzeigen ----SSSS weist den Compiler an, den erzeugten Code als Assembler-Quelltext auszugeben ----vvvv gibt die Compiler-Version aus. ----EEEE nur bis Peprocessor (standart output)

-SSSS nur bis compiler(*.s enthält Assembly Language)

----cccc Nur bis Assembler (*.o enthält Object File)

----dddd debug Define

g++ -Wall –o hello_world hello_world.cpp

3.23.23.23.2 NamespacesNamespacesNamespacesNamespaces

damit kann man logische Gruppen von Symbolen definieren (Module, Libraries), ohne Namenskonflikte zu riskieren

3.33.33.33.3 Eigenschaften des Datentyps boolEigenschaften des Datentyps boolEigenschaften des Datentyps boolEigenschaften des Datentyps bool

� GrößeGrößeGrößeGröße: : : :

1 Byte (etwas Verschwendung da nur 1 Bit benötigt wird).

� EigenschaftenEigenschaftenEigenschaftenEigenschaften::::

Alles was ungleich 0 ist wird als 1 gewertet (auch negative Werte).

Also:

bool b= false; b=17; std::cout<<b; // 1


Fragen

12

3.43.43.43.4 Eigenschaften des Datentyps constEigenschaften des Datentyps constEigenschaften des Datentyps constEigenschaften des Datentyps const

Belegt kein Speicher, daher kann sie auch nicht verändert werden!

Ist „left bindingleft bindingleft bindingleft binding“ also wirkt auf den Teil links davon. Aber wenn rechts davon und links davon nicht steht wird das was rechts steht genommen.

Typ kann vom Compiler geprüft werden.

� BspBspBspBsp::::

const float �wirkt auf float.

float const �wirkt auf float.

const char* �wirkt auf char also auf den String innerhalb� Buchstaben lassen sich nicht verändern!

char const * �wirkt auf char also auf den String innerhalb.

char* const �wirkt auf char**** also macht die AdresseAdresseAdresseAdresse wo der String steht konstant, der String lässt sich aber verändernString lässt sich aber verändernString lässt sich aber verändernString lässt sich aber verändern!!!!!!!!!!!!

� Funktionen: constFunktionen: constFunktionen: constFunktionen: const----ParameParameParameParameterterterter

Const in der Parameter-Deklaration teilt dem Compiler mit, dass der Parameter nicht verändert wird (obwohl er per Reference oder Pointer übergeben wurde).

Compiler verbietet dann Modifikation im Funktions-Code.

Erlaubt Übergabe von Konstanten.

Erlaubt Optimierungen durch Compiler.

Verändert Signatur.

� Konstante MethodeKonstante MethodeKonstante MethodeKonstante Methode

Sagt dem Compiler, dass diese Methode die Attribute des Objektes nicht verändert.

Syntax: z.B.:void print() const;

Nur dann kann diese Methode auf Objekte, die selbst als konstant an eine Funktion (bzw. Methode) übergeben wurden, angewendet werden.

Typischerweise für alle getter-Methoden verwendet


Fragen

13

3.53.53.53.5 Welchen Vorteil hat die VariablenWelchen Vorteil hat die VariablenWelchen Vorteil hat die VariablenWelchen Vorteil hat die Variablen----Definition in conditionDefinition in conditionDefinition in conditionDefinition in condition

Scope ist limitiert auf den von der Kontroll-Struktur (if/else, while, for) kontrollierten Bereich.

� Bsp:Bsp:Bsp:Bsp:

for ( int i=0; i<10; i++){std::cout << i << std::endl;}

3.63.63.63.6 ErklärenErklärenErklärenErklären Sie OverloadingSie OverloadingSie OverloadingSie Overloading

Overloading (de. überladen): man kann gleichnamige Methoden innerhalb einer Klasse implementieren, welche sich aber durch die Signatur unterscheiden müssen.

3.73.73.73.7 ErkErkErkErklären Sie Overritinglären Sie Overritinglären Sie Overritinglären Sie Overriting

Die abgeleitete Klasse kann Methoden der Basisklasse neu definieren (Overriding).

3.83.83.83.8 Wie setzt sich die Signatur einer Methode zusammenWie setzt sich die Signatur einer Methode zusammenWie setzt sich die Signatur einer Methode zusammenWie setzt sich die Signatur einer Methode zusammen

Signatur = FunktionsnameFunktionsnameFunktionsnameFunktionsname + ParameterParameterParameterParameter----AnzahlAnzahlAnzahlAnzahl + ParameterParameterParameterParameter----TypTypTypTyp.

Exception zählt auch dazu.

Const-Parameter veränder Signatur.

Nicht berücksichtigt: return typ.

3.93.93.93.9 Default ParameterDefault ParameterDefault ParameterDefault Parameter

Default-Parameter können beim Aufruf auch weggelassen werden. In diesem Fall wird ein Default-Wert eingesetzt.

Beliebig viele möglich, aber immer nur am Endenur am Endenur am Endenur am Ende

Wenn Prototyp und Implementation getrennt: Nur beim Prototyp angeben: Nur beim Prototyp angeben: Nur beim Prototyp angeben: Nur beim Prototyp angeben!

z.B.:

void drawCircle(intx, inty, floatradius= 1.0); drawCircle(0,0,1.5);drawCircle(2,2);


Fragen

14

3.103.103.103.10 Erklären Sie Funktionen mit dem Schlüsselwort „inline“Erklären Sie Funktionen mit dem Schlüsselwort „inline“Erklären Sie Funktionen mit dem Schlüsselwort „inline“Erklären Sie Funktionen mit dem Schlüsselwort „inline“

� BspBspBspBsp::::

inline double circleArea(double radius) { returnradius* radius* PI; }

Statt Funktionsaufruf wird direkt der Code eingesetzt.

(Potentiell) schnellerer, aber größerer Code.

Kein Pointer auf diese Funktion möglich.

Ähnlich wie Makro, aber mit Typenprüfung.

Virtuelle MethodenVirtuelle MethodenVirtuelle MethodenVirtuelle Methoden können nicht inline expandiert werden.

3.113.113.113.11 Was wissen Sie über die Sichtbarkeit von Klassen Attributen u Was wissen Sie über die Sichtbarkeit von Klassen Attributen u Was wissen Sie über die Sichtbarkeit von Klassen Attributen u Was wissen Sie über die Sichtbarkeit von Klassen Attributen u Methoden.Methoden.Methoden.Methoden.

Reihenfolge beliebig

Kann auch öfter pro Klasse vorkommen

� private:private:private:private: Nur sichtbar für eigene MethodenNur sichtbar für eigene MethodenNur sichtbar für eigene MethodenNur sichtbar für eigene Methoden

� public: public: public: public: Sichtbar von aussenSichtbar von aussenSichtbar von aussenSichtbar von aussen

� protected:protected:protected:protected: SiSiSiSichtbar für abgeleitete Klassen chtbar für abgeleitete Klassen chtbar für abgeleitete Klassen chtbar für abgeleitete Klassen

3.123.123.123.12 Welche Möglichkeiten gibt es Methoden zu implementierenWelche Möglichkeiten gibt es Methoden zu implementierenWelche Möglichkeiten gibt es Methoden zu implementierenWelche Möglichkeiten gibt es Methoden zu implementieren

� Als "echte" Funktion Als "echte" Funktion Als "echte" Funktion Als "echte" Funktion

In der Klassen-Definition nur Prototyp.

Implementation: mit Klassennamen als Namespace; "irgendwo sonst".

� InlineInlineInlineInline

Direkt in der Klassen-Definition implementieren.

Mit Schlüsselwort inline bei der Definition.

3.133.133.133.13 Besitzen Konstruktoren einen RückgabewertBesitzen Konstruktoren einen RückgabewertBesitzen Konstruktoren einen RückgabewertBesitzen Konstruktoren einen Rückgabewert

Nein.

Im Fehlerfall sollte ein Exception geworfen werden!


Fragen

15

3.143.143.143.14 Was wissen sie über den Copy KonstruktorWas wissen sie über den Copy KonstruktorWas wissen sie über den Copy KonstruktorWas wissen sie über den Copy Konstruktor

Wird automatisch aufgerufen, wenn eine Kopie eines Objekts erzeugt werden muss.

Z.B:

Bei der Initialisierung eines Objektes als Kopie eines anderen.

Bei Übergabe eines Objektes als callcallcallcall----bybybyby----valuevaluevaluevalue Funktionsparameter.

Beim "returnreturnreturnreturn" einer Funktion mit einem Objekt als Return-Wert.

Syntax:class X { public: X (const X &); // copyconstructor} }

� Problem:Problem:Problem:Problem:

Der automatisch generierte Copy Constructor kopiert einfach die Attribute.

D.h. in diesem Fall die Pointer (shallow copy), nicht den Inhaltnicht den Inhaltnicht den Inhaltnicht den Inhalt (deep copy).

Wird zum Bsp: (temporären) Kopie durch Copy Constructor erzeugt zeigt die Kopie im Fall von Pointer nur diese. Wenn das kopierte Objekt aus irgendeinem Grund zerstört wird gibt der Destuktor den Speicher frei. � OriginalOriginalOriginalOriginal----Objekt hat Pointer auf freigegebenen Speicher (!!!)Objekt hat Pointer auf freigegebenen Speicher (!!!)Objekt hat Pointer auf freigegebenen Speicher (!!!)Objekt hat Pointer auf freigegebenen Speicher (!!!)

� LösungenLösungenLösungenLösungen::::

Einen Copy-Constructor mit deep copy implementieren (public).

Copy-Constructor sollte als private deklarieren.

3.153.153.153.15 Was wissen sie über den Default KonstruktorWas wissen sie über den Default KonstruktorWas wissen sie über den Default KonstruktorWas wissen sie über den Default Konstruktor

Notwendig, damit Objekte dieses Typs ohne Parameter erzeugt werden können.

Ruft Konstruktoren aller Member-Attribute auf, die selbst Klassen sind

Primitive Datentypen bleiben uninitialisiert!


Fragen

16

3.163.163.163.16 Was wissen sie über den DestuktorWas wissen sie über den DestuktorWas wissen sie über den DestuktorWas wissen sie über den Destuktor

Sollte virtual sein.

Darf keine Exception werfen.

Destruktor ist immer ohne Parameter und Rückgabewert.

Nur ein Destruktor möglich (~Klassenname).

3.173.173.173.17 Erklären Sie ihnen alle bekannten Erklären Sie ihnen alle bekannten Erklären Sie ihnen alle bekannten Erklären Sie ihnen alle bekannten SpeicherklasSpeicherklasSpeicherklasSpeicherklassensensensen

3.183.183.183.18 Was und warum geschieht bei der globale /statischer Was und warum geschieht bei der globale /statischer Was und warum geschieht bei der globale /statischer Was und warum geschieht bei der globale /statischer Def. von Def. von Def. von Def. von VariablenVariablenVariablenVariablen/Arrays/Arrays/Arrays/Arrays

Diese werden automatisch mit 0 initialisiert.

� Achtung: gilt nur für:Achtung: gilt nur für:Achtung: gilt nur für:Achtung: gilt nur für:

Globale Variablen.

Mit staticstaticstaticstatic deklarierte lokale Variablen oder Klassen-Attribute.

3.193.193.193.19 Was wissen Sie übeWas wissen Sie übeWas wissen Sie übeWas wissen Sie über Klassen Attributer Klassen Attributer Klassen Attributer Klassen Attribute/Methoden/Methoden/Methoden/Methoden

Gehören zur Klasse, nicht zu einer konkreten Instanz.

Existieren genau einmalExistieren genau einmalExistieren genau einmalExistieren genau einmal, unabhängig von Instanzen.

Klassen-Methoden können unabhängig von einer Instanz aufgerufen werden


Fragen

17

Klassen-Methoden können nichtkönnen nichtkönnen nichtkönnen nicht auf InstanzInstanzInstanzInstanz----VariablenVariablenVariablenVariablen zugreifenzugreifenzugreifenzugreifen (aber auf Klassen-Attribute und -Methoden).

Definiert mit Schlüsselwort "static""static""static""static"....

Klassen-Attribute werden automatisch mit 0 initialisiert, sofern nichts anderes definiert wird.

3.203.203.203.20 Welche Möglichkeiten gibt es Klassen Attribute Konstant zu machenWelche Möglichkeiten gibt es Klassen Attribute Konstant zu machenWelche Möglichkeiten gibt es Klassen Attribute Konstant zu machenWelche Möglichkeiten gibt es Klassen Attribute Konstant zu machen

� const Attributconst Attributconst Attributconst Attribut

Muss initialisiert werden (in der Initialisierungsliste; kann nicht per

Zuweisung geändert werden).

Braucht Speicher (pro Objekt!).

Kann pro Objekt unterschiedlicher (aber konstanter) Wert sein.

� static const Attributstatic const Attributstatic const Attributstatic const Attribut

Braucht nur einmal Speicher (pro Klasse).

Muss bei der Definition initialisiert werden.

Für alle Objekte gleichFür alle Objekte gleichFür alle Objekte gleichFür alle Objekte gleich!!!!!!!!!!!!

� Anonymes enumAnonymes enumAnonymes enumAnonymes enum

Braucht keinen Speicher

Compiler setzt statt dem symbolischen Namen den Wert ein

Keine Adresse verfügbar.

3.213.213.213.21 Warum sollte ein virtueller Destuktor verwendWarum sollte ein virtueller Destuktor verwendWarum sollte ein virtueller Destuktor verwendWarum sollte ein virtueller Destuktor verwendet werdenet werdenet werdenet werden

Notwendig bei Basisklassen, damit der Destruktor der abgeleiteten Klasse dynamisch gefunden und aufgerufen werden kann.

Ist daher wichtig, sogar wenn er nichts tut.

Oft weiss man zunächst noch nicht, dass später von einer Klasse abgeleitet werden wird.

[SEP] Ausarbeitung Kapitel #4

Fragen

18

4 Kapitel #4

4.14.14.14.1 Was sind Abstrakte KlassenWas sind Abstrakte KlassenWas sind Abstrakte KlassenWas sind Abstrakte Klassen

Klassen, von denen keine Objekte (Instanzen) erzeugt werden können Nur von davon abgeleiteten Klassen können Objekte erzeugt werden. Abstrakte Klasse sind sozusagen "Hilfsklassen", die gemeinsame Eigenschaften und Fähigkeiten der davon abgeleiteten Klassen zusammenfassen.

Sie besitzen mind. EINE REIN VIRTUELEINE REIN VIRTUELEINE REIN VIRTUELEINE REIN VIRTUELLELELELE Methode. Deshalb kann keine Instanz erzeugt werden!

� WarumWarumWarumWarum::::

Eine rein virtuelle Methode wird in der Basis Klasse (Abstrakten Klasse) per Definition mit:

virtual methode()=0;

deklariert, also sozusagen der NULL-Pointer zugewiesen. Deshalb zeigt die Methode auf einen ungültigen Bereich, weshalb das Erzeugen einer Instanz nicht erlaubt ist. Wenn man aber =0 wegelässt ist das Erzeugen einer Instanz erlaubt.

Eine konkrete Subklasse muss alle rein virtuellen Methoden implementieren Eine konkrete Subklasse muss alle rein virtuellen Methoden implementieren Eine konkrete Subklasse muss alle rein virtuellen Methoden implementieren Eine konkrete Subklasse muss alle rein virtuellen Methoden implementieren (nur dann können solche Objek(nur dann können solche Objek(nur dann können solche Objek(nur dann können solche Objekte erzeugt werden)te erzeugt werden)te erzeugt werden)te erzeugt werden)

4.24.24.24.2 Was versteht man unter Was versteht man unter Was versteht man unter Was versteht man unter static_cast<>()static_cast<>()static_cast<>()static_cast<>()

Zu verwenden, wenn Compiler zur Compile-Zeit ("statisch") entscheiden kann, wie konvertiert werden soll.

Konvertierungen zwischen Standard-Datentypen

Konvertierungen in Klassentypen, die durch einparametrige Konstruktoren definiert sind.

float pi=3.14; int i_pi= static_cast<int>(pi);

4.34.34.34.3 Was versteht man unter dynamicWas versteht man unter dynamicWas versteht man unter dynamicWas versteht man unter dynamic_cast<>()_cast<>()_cast<>()_cast<>()

Zur Konvertierung von Pointern innerhalb einer Vererbungshierarchie

"DownCast": Aus einem Zeiger auf eine Basisklasse einen Zeiger auf eine abgeleitete Klasse machen.


Fragen

19

Geht nur, wenn das Objekt tatsächlich vom Typ der abgeleiteten Klasse ist.

D.h. kann vom Compiler nicht geprüft werden, sondern muss zur Laufzeitmuss zur Laufzeitmuss zur Laufzeitmuss zur Laufzeit ("dynamisch") geprüft("dynamisch") geprüft("dynamisch") geprüft("dynamisch") geprüft werden.

dynamic_cast<>() liefert NULL-pointer, wenn Pointer nicht vom angegebenen Typ ist, sonst den Pointer

Setzt voraus, dass Basisklasse polymorph ist (zumindest 1 virtual Methodezumindest 1 virtual Methodezumindest 1 virtual Methodezumindest 1 virtual Methode).

Person* p1=new Student(); Student* s1= dynamic_cast<Student*>(p1) ;

4.44.44.44.4 Was versteht man unterWas versteht man unterWas versteht man unterWas versteht man unter reinterpret_cast<>()reinterpret_cast<>()reinterpret_cast<>()reinterpret_cast<>()

Manchmal (sehr selten!!!) muss man Daten ohne Prüfung um-interpretieren

z.B. einen Pointer als int interpretieren, um ihn auszugeben.

z.B. Pointer auf Objekte, die nicht in einer "Basisklassen-Subklassen- Beziehung" zueinander stehen, ineinander umwandeln

z.B. void*void*void*void* von C-Funktionen wie mallocmallocmallocmalloc in etwas umwandeln

Person* p1=new Student(); int prt = reinterpret_cast<int>(p1);

4.54.54.54.5 Was versteht man unterWas versteht man unterWas versteht man unterWas versteht man unter constconstconstconst_cast<>()_cast<>()_cast<>()_cast<>()

Entfernt Entfernt Entfernt Entfernt die constconstconstconst----SpezSpezSpezSpezifikation ifikation ifikation ifikation eines Pointers oder einer Referenz.

Eine Methode, die nicht const deklariert wurde, soll mit einer const-Referenz oder -Pointer aufgerufen werden.

Eine als const deklarierter Parameter ist nicht wirklich const.


Fragen

20

5 Kapitel #5

5.15.15.15.1 Syntax ExceptionesSyntax ExceptionesSyntax ExceptionesSyntax Exceptiones

try { ... throw <exception-type>(<params>); ... } catch (<exception-type> <exception-variable>) { ... }

5.25.25.25.2 Was passiert wenn eine ExWas passiert wenn eine ExWas passiert wenn eine ExWas passiert wenn eine Excccception geworfen wirdeption geworfen wirdeption geworfen wirdeption geworfen wird

Die Execution des try-Blocks wird an dieser Stelle beendet.

Der Stack wird bis zur Umgebung des try-Blocks abgebaut ("stack unwinding"): Destruktoren von auto-Variablen werden korrekt aufgerufen, Speicher von auto-Variablen wird freigegeben.

Ein "passender" catch-Block wird gesucht, und dort das Programm weiter ausgeführt.

5.35.35.35.3 Was ist bei Exception generell zu beacWas ist bei Exception generell zu beacWas ist bei Exception generell zu beacWas ist bei Exception generell zu beachtenhtenhtenhten

�Nur auto-Variablen werden automatisch freigegeben !

�Code nach throw wird nicht mehr exekutiert !

�Es können mehrere catch-Blöcke pro try-Block existieren. Die Auswahl erfolgt auf Basis des Typsdes <exception-type>

�Typ-Vergleich erfolgt in der Reihenfolge im Source-Code

�Alle Standard-Exceptions sind von std::exception abgeleitet

�catch (std::exception&e)fängt alle Standard-Exceptions ab, die nicht vorher durch speziellere "catches" abgefangen wurden

�Daher: Speziellere Exceptions zuerst "catchen", allgemeinere danach

�try-Blöcke können ineinander verschachtelt werden. Exceptions, die ein try-Block nicht "catcht", werden an den "nächsten" am Stack weitergereicht (dynamischeAuswertung!)

�Catch-Blöcke können eine Exception auch nur teilweise behandeln und sie per throw an den "nächsten" am Stack weiterreichen


Fragen

21

5.45.45.45.4 Was passiert wenn eine Methode eine andere Exception wirft als in Was passiert wenn eine Methode eine andere Exception wirft als in Was passiert wenn eine Methode eine andere Exception wirft als in Was passiert wenn eine Methode eine andere Exception wirft als in der Deklaration definiertder Deklaration definiertder Deklaration definiertder Deklaration definiert

Programm wird terminiert.

5.55.55.55.5 Funktionen mit/ohne ExceptionsFunktionen mit/ohne ExceptionsFunktionen mit/ohne ExceptionsFunktionen mit/ohne Exceptions

Ist Teil der Signatur.

Es dürfen von dieser Methode garantiert keine anderen Exceptions geworfen werden.

Ohne Angabe: Beliebige Exceptions möglich.

Wenn, throw() deklariert heißt, dass keine Exceptions geworfen werden.

5.65.65.65.6 Auf was, ist bei SELBST def. Exception Klassen zu achtenAuf was, ist bei SELBST def. Exception Klassen zu achtenAuf was, ist bei SELBST def. Exception Klassen zu achtenAuf was, ist bei SELBST def. Exception Klassen zu achten

�Der Destruktor, Konstruktor, Copy-Konstruktor darf keine Exceptions werfen.

�Als Member-Variablen von Exception Klassen dürfen keine Klassen verwendet werden, die bei der Instanziierung eine Exception werfen könnten!!!

z.B std::string

�catch sollte exception by reference "fangen", da sonst der Copy-Konstruktor implementiert werden müsste.

5.75.75.75.7 Was passiert, Was passiert, Was passiert, Was passiert, wenn im Konstruktor eine Exceptionwenn im Konstruktor eine Exceptionwenn im Konstruktor eine Exceptionwenn im Konstruktor eine Exception geworfen wirdgeworfen wirdgeworfen wirdgeworfen wird

Das Objekt als nicht konstruiert�Destuktor wird am End der Lebenszeit nicht aufgerufen!!

D.h Variable am Heap müssen freigegeben werden.

Aber:Aber:Aber:Aber:

Destuktor einer eventuellen Basisklasse wird schon aufgerufen.

Ebenso die Destruktoren aller Member-Variablen, die vor der Exception schon fertig konstruiert waren. D.h besser Member von der Klasse std::string verwenden als char*.

5.85.85.85.8 Was passiert, wenn im Destuktor eine Exception geworfen wiWas passiert, wenn im Destuktor eine Exception geworfen wiWas passiert, wenn im Destuktor eine Exception geworfen wiWas passiert, wenn im Destuktor eine Exception geworfen wirdrdrdrd

Destruktor könnte beim "stack unwinding" einer Exception aufgerufen werden und selbst eine Exception auslösen ⇒ Programm wird beendet.


Fragen

22

6 Kapitel #6

6.16.16.16.1 Wobei hilft das Schlüsselwort friendWobei hilft das Schlüsselwort friendWobei hilft das Schlüsselwort friendWobei hilft das Schlüsselwort friend

Durch friend wird der Zugriff auf alle Membersalle Membersalle Membersalle Members(nicht möglich, nur den Zugriff auf gewisse Members freizugeben) der eigenen Klasseerlaubt.

� z.B.:z.B.:z.B.:z.B.:

friend class B; // all methods from B may access friend void B::f() // only method f() in B may acce ss friend global_f() // global_fmay access my members

6.26.26.26.2 Wann solWann solWann solWann solllllte der Zuweisungte der Zuweisungte der Zuweisungte der Zuweisungsoperatorsoperatorsoperatorsoperator public gesetzt public gesetzt public gesetzt public gesetzt wewewewerden wann rden wann rden wann rden wann nichtnichtnichtnicht

Public wenn z.B. (Kann überladen werden), um andere Typen in den Typ des linken Operanden zu konvertieren.

Sollte private deklariert werden um implizierte Aufrufe zu verhindern. Denn Default Operator macht nur ein "shallow copy".

6.36.36.36.3 Welches Problem muss beim ZuweisungsoperatorWelches Problem muss beim ZuweisungsoperatorWelches Problem muss beim ZuweisungsoperatorWelches Problem muss beim Zuweisungsoperator

Zuweisung an sich selbst muss abfangen werden.

6.46.46.46.4 Welches Problem entsteht beim << operatorWelches Problem entsteht beim << operatorWelches Problem entsteht beim << operatorWelches Problem entsteht beim << operator

Kann nicht virtuell deklariert werden.

6.56.56.56.5 Wie kann der <<operator „virtuell“ gemacht werdenWie kann der <<operator „virtuell“ gemacht werdenWie kann der <<operator „virtuell“ gemacht werdenWie kann der <<operator „virtuell“ gemacht werden

operator<< nur für Basisklasse implementieren, und darin eine virtuelle Methode aufrufen, die das Objekt auf ostream ausgibt. Diese virtuelle Methode jeweils in den abgeleiteten Klassen implementieren.


Fragen

23

7 Kapitel #7

7.17.17.17.1 Beschreiben Sie das Diamond Problem:Beschreiben Sie das Diamond Problem:Beschreiben Sie das Diamond Problem:Beschreiben Sie das Diamond Problem:

Members von R sind zweimal im Speicher. Referenz ist nicht eindeutig (⇒

Compiler-Error). Nicht mehr polymorph verwendbar

� Konstruktoren würden also Members von R zweimal anlegen.

7.27.27.27.2 Wie wird das Diamond Problem gelöstWie wird das Diamond Problem gelöstWie wird das Diamond Problem gelöstWie wird das Diamond Problem gelöst

Basis Klasse R wird virtual vererbt.

class R { ... }; class A : virtual public R { ... }; class B : public virtual R { ... }; class X : public A, public B { ... }

Dadurch werden die Members von R nur einmal erzeugt.


Fragen

24

7.37.37.37.3 Welche Besonderheiten ergeben sich durch MehrfachvererbungWelche Besonderheiten ergeben sich durch MehrfachvererbungWelche Besonderheiten ergeben sich durch MehrfachvererbungWelche Besonderheiten ergeben sich durch Mehrfachvererbung

Die Konstruktoren von A und B konstruieren beide auch R möglicherweise auf unterschiedliche Weise.

Der Konstruktor von X konstruiert sowohl A als auch B ⇒ R würde zweimal

(unterschiedlich?) konstruiert werden.

Lösung: Der Compiler unterdrückt die automatische Konstruktion (in der Initialisierungsliste) von R durch A und B bei Konstruktion von X

⇒ Beim Konstruktor von X (bzw. allen irgendwie von R virtuell abgeleiteten

Klassen) muss explizit angegeben werden, wie R konstruiert werden soll (in der Initialisierungsliste) !

� KonstruktorKonstruktorKonstruktorKonstruktor::::

PhDstudent(membersPerson, membersStudent, membersPr of, members) : Person (membersPerson), Student (membersPerson,membersStudent), Professor (membersPerson, membersProf), members_(members) {…}

Virtuelle MethodenVirtuelle MethodenVirtuelle MethodenVirtuelle Methoden, die in A und B implementiert wurden, müssen auch in Xmüssen auch in Xmüssen auch in Xmüssen auch in X

implementiertimplementiertimplementiertimplementiert werden (⇒ eindeutig)

7.47.47.47.4 Vorteil von templatesVorteil von templatesVorteil von templatesVorteil von templates

Compiler findet und compiliert automatisch den benötigten Code für die Funktion, und setzt deren Aufruf ein.

7.57.57.57.5 Welche Arten von templates kennen SieWelche Arten von templates kennen SieWelche Arten von templates kennen SieWelche Arten von templates kennen Sie

Klassen templates.

Funktionstemplates.

7.67.67.67.6 Worauf muss bei Klassentemplates geaWorauf muss bei Klassentemplates geaWorauf muss bei Klassentemplates geaWorauf muss bei Klassentemplates geachtet werdenchtet werdenchtet werdenchtet werden

Definition und Implementation zusammen in einen .h File

7.77.77.77.7 Nennen Sie ein Beispiel für ein FunktionstemplateNennen Sie ein Beispiel für ein FunktionstemplateNennen Sie ein Beispiel für ein FunktionstemplateNennen Sie ein Beispiel für ein Funktionstemplate

template <typename T> T min (T a, T b) { return (a < b) ? a : b; }


Fragen

25

8 Kapitel #8

8.18.18.18.1 Was heißt STLWas heißt STLWas heißt STLWas heißt STL

Standart template libary

8.28.28.28.2 Welche VorteileWelche VorteileWelche VorteileWelche Vorteile hat ein Autohat ein Autohat ein Autohat ein Auto----PPPPointerointerointerointer

Übernimmt Verantwortung für das "echte" Objekt.

Gibt Speicher dafür frei, wenn das auto_ptr Objekt freigegeben wird.

Operatoren * und -> sind überladen und addressieren das "echte" Objekt

Objekte können dynamisch instanziiert werden, verhalten sich aber wie

auto-Variablen (automatische Speicher-Freigabe am Ende des Blocks)

Besonders praktisch bei Exceptions (werden durch StackStackStackStack----UnwindingUnwindingUnwindingUnwinding

automatisch freigegebenautomatisch freigegebenautomatisch freigegebenautomatisch freigegeben)

8.38.38.38.3 Was passiert bei einer Kopie eines AutoWas passiert bei einer Kopie eines AutoWas passiert bei einer Kopie eines AutoWas passiert bei einer Kopie eines Auto----PointerPointerPointerPointer

Durch eine Kopie geht die Verantwortung an die Kopie über.

8.48.48.48.4 Welche Vorteile bieten StreamsWelche Vorteile bieten StreamsWelche Vorteile bieten StreamsWelche Vorteile bieten Streams

Praktisch, um numerische Daten in einen string zu schreiben, bzw. von einem String zu lesen

8.58.58.58.5 Was ist ein Vektor und welche Eigenschaften besitzt erWas ist ein Vektor und welche Eigenschaften besitzt erWas ist ein Vektor und welche Eigenschaften besitzt erWas ist ein Vektor und welche Eigenschaften besitzt er

Sich dynamisch erweiterndes Array.

Speicher-effizient (ein zusammenhängender Block).

Schneller Zugriff auf beliebiges Element ([ ] Operator).

Geprüfter Zugriff (at()Methode, wirft std::range_errorException).

Schnelles Einfügen und Löschen am Ende.

Langsames Einfügen und Löschen in der Mitte.


Fragen

26

8.68.68.68.6 Was sWas sWas sWas sind Iteratorenind Iteratorenind Iteratorenind Iteratoren

Einheitliche Abstraktion des (sequentiellen) Zugriffs auf Container. Mehrere Iteratoren können auf demselben Container arbeiten.

Iteratoren sind "eingeschachtelte" Typen des Containers (z.B.

list<int>::iterator)

Überladene Operatoren: = ++ -- == != -> *

vector und deque zusätzlich: + - += -= < > <= >= []

begin() liefert konstanten Iterator, der auf das erste Element zeigt

end() zeigt auf ein ungültiges Element hinter dem letzten Element

(für Vergleiche)

8.78.78.78.7 Welche Arten von Container kennen SieWelche Arten von Container kennen SieWelche Arten von Container kennen SieWelche Arten von Container kennen Sie

� list<T, Alloc>list<T, Alloc>list<T, Alloc>list<T, Alloc>

doppelt verkettete Liste

Iteratoren bleiben auch nach Einfüge- und Löschoperationen gültig

� deque<T, Alloc>deque<T, Alloc>deque<T, Alloc>deque<T, Alloc>

Eigenschaften wie vector

Aber zusätzlich schnelles Einfügen und Löschen am Anfang

� set<Key, Compare, Alloc>set<Key, Compare, Alloc>set<Key, Compare, Alloc>set<Key, Compare, Alloc>

Assoziativer Container (Zugriff erfolgt über Key)

Realisiert als Binärbaum

Jedes Element kann nur einmal vorkommen (Menge)

Iteratoren bleiben auch nach Einfüge- und Löschoperationen gültig

� multiset<Key, Compare, Alloc>multiset<Key, Compare, Alloc>multiset<Key, Compare, Alloc>multiset<Key, Compare, Alloc>

wie set, aber Elemente können mehrfach vorkommen

� map<Key, Dmap<Key, Dmap<Key, Dmap<Key, Data, Compare, Alloc>ata, Compare, Alloc>ata, Compare, Alloc>ata, Compare, Alloc>

Elemente sind vom Typ pair<Key, Data>

Attribut pair::first liefert Key, pair::second die Daten

Operator [key] sucht das Element mit dem Schlüssel 'key', bzw. erlaubt

(auf der linken Seite eines = Operators) das Einfügen eines neuen


Fragen

27

Elementes, wenn der key noch nicht existiert ansonsten Eigenschaften wie set

� multimap<Key, Data, Compare, Alloc>multimap<Key, Data, Compare, Alloc>multimap<Key, Data, Compare, Alloc>multimap<Key, Data, Compare, Alloc>

Wie map, aber Elemente können mehrfach vorkommen

8.88.88.88.8 Container Container Container Container –––– AdapterAdapterAdapterAdapter

� stack<T, Container>stack<T, Container>stack<T, Container>stack<T, Container>

Stellt Methoden push(<T>) und pop() zur Verfügung

Last In First Out (LIFO)

top() liefert das oberte Element

Container kann deque<T> (=default), list<T>, oder vector<T> sein

� queue<T, Container>queue<T, Container>queue<T, Container>queue<T, Container>

ähnlich wie stack, aber FIFO (First In First Out)

Container kann deque<T> (=default) oder list<T> sein

� priority_queue<T, Container, Comparepriority_queue<T, Container, Comparepriority_queue<T, Container, Comparepriority_queue<T, Container, Compare>

wie queue, aber Elemente sind sortiert

Container kann deque<T> (=default) oder list<T> sein

8.98.98.98.9 AlgorithmenAlgorithmenAlgorithmenAlgorithmen

� #include <algorithm>#include <algorithm>#include <algorithm>#include <algorithm>

enthält viele Standard-Algorithmen für Container

Zugriff erfolgt über Iteratoren

⇒ dadurch unabhängig von der Art des Containers

⇒ für jeden Daten-Typ des Containers (solange Operatoren definiert sind)

� Z.B.:Z.B.:Z.B.:Z.B.:

sort(iterator start, iterator end);

Impressum

[SE

P]

Au

sarb

eitu

ng

Datum: 6. Juni 2009 Rev: 00 Autor: Christian L.

Documents

Software Entwicklung Praktikum [SEP] - arcustan.com Praktikum/SEP...[SEP] Ausarbeitung 2 Ausarbeitung aus dem VO-Stoff, erhebt keinerlei Anspruch auf Vollständigkeit oder Korrektheit