Das Klassenkonzept von C++ - MISTRAL, TU-Muenchen

Das Klassenkonzept von C++
● Eine Klasse definiert einen abstrakten Datentypen, d.h.
– die Schnittstelle und
– die Implementierung von Objekten
● Objekte sind die konkreten Instanzen/Ausprägungen
der Klasse
● Klassenkonzept von C++ stammt von Simula67
– Erweiterung von Strukturen durch die Einführung von verschatteten
Zustandsvariablen und Methoden
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 35

Das Klassenkonzept von C++ (2)
● Class klingt objektorientierter als struct
– class{...} = struct { private: ...}
– struct{...}= class{ public: ...}
● Bestandteile einer Klasse - Members:
– Daten: Zustandsvariablen
– Operationen: Methoden
class Name {
public:
...
private:
...};
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 36

Beispiel: Depotverwaltung
● In C++:
class Depot {
public: // public members immer zuerst wg. Lesbarkeit
Depot();
// Standardkonstruktor
int Kontostand() {return Barvermögen}; // automatisch inline
void Einzahlung(int betrag) {Barvermögen+=betrag};
private:
int DepotNr;
string Name;
int Barvermögen;
vector Bestand;
};
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 37

Zugriffsregelung
● Der Zugriff auf Members kann folgendermaßen
eingeschränkt werden:
– public: keine Zugriffsbeschränkung
– private: ausschließlich innerhalb der Klasse zugreifbar
Ausnahme: friend Funktionen und Klassen
● Friend-Funktionen und Klassen: erlaubt
klassenexternen Funktionen und anderen Klassen auf
die private Members zuzugreifen
– Friend-Klassen und Friend-Funktionen müssen in der Klassendefinition
deklariert werden
– Achtung: Friends sparsam verwenden, da das Kapselungskonzept
verletzt wird!
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 38

Konstruktoren
● Konstruktoren sind spezielle Methoden der Klassen, die
die Objekte erzeugen und initialisieren
– der Name der Konstruktoren entspricht dem Klassennamen
– vor der Ausführung des Konstruktorrumpfes wird Speicherplatz für die
Zustandsvariablen des Objektes angelegt
– jede Klasse hat einen Standardkonstruktor (default constructor) der bei
der Erzeugung aufgerufen wird
» enthält keine Argumente
» kann selbst definiert werden
» muß immer ohne Klammern aufgerufen werden
– allgemeine Konstruktoren können definiert werden um die Objekte
unterschiedlich zu initialisieren ÅÜberladung
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 39

Konstruktoren (2)
● Copy-Konstruktor C::C(const C& c);
– Erzeugung eines neuen Objektes als eine Kopie eines Objektes
derselben Klasse
– konstante Referenz um eine Änderung der Quelle zu verhindern +
Effizienz
– wird nicht bei Zuweisung ausgeführt!
● Initialisierung der Zustandsvariablen
– im Rumpf des Konstruktors
– als Initialisierungsliste: bevor Rumpf des Konstruktors ausgeführt wird
● Typumwandlungskonstruktoren
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 40

in Header File
Beispiel:
class Depot {
public: // public members immer zuerst wg. Lesbarkeit
Depot();
// Standardkonstruktor
Depot(int Nr, string Name): DepotNr(Nr), Name(Name),
Barvermögen(0) {};
int Kontostand() {return Barvermögen}; // automatisch
inline
...
};
// in .cc file
inline void Depot::Einzahlung(int betrag)
{Barvermögen+=betrag}
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 41

Destruktoren
● Destruktoren verrichten die Aufräumarbeiten, d.h.
Resourcenfreigabe für nicht mehr benötigte Objekte
– Speicherfreigabe, Dateien schließen, etc.
– Destruktoren haben keine Argumente (Å es gibt nur einen pro Klasse)
und keinen Rückgabetyp: ~C()
– Destruktoren werden vom System automatisch erzeugt, wenn nicht
vorgegeben
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 42

weitere Klassenkonzepte
● This-Zeiger: this verweist innerhalb einer Methode auf
das aktuelle Objekt
Å *this ist ein Alias für das Objekt selbst
● Konstante Objekte:
– Methoden von konstanten Objekten dürfen nicht aufgerufen werden
» Ausnahme: Methode ist als const deklariert und definiert
– const Objekte können nicht durch Methoden geändert werden (auch
nicht durch const Methoden)
» Ausnahmen:
●
●
explizite Typumwandlung: „casting the const away“
mutable Variablen
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 43

Klassenspezifische Members
● static Zustandsvariablen und static Methoden
● existieren nur einmal für die gesamte Klasse: z.B.
Objektzähler, Konstruktoren
● Definition und Initialisierung statischer
Zustandsvariablen nur einmal; außerhalb der
Klassendefinition
● auf static Methoden kann direkt (d.h. ohne Objekt
zugegriffen werden)
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 44

in .h
Beispiel
class numeriertesObjekt // noch nicht vollständig! {
};
public:
numeriertesObjekt();
static int Anzahl() { return anzahl;}
private:
static int anzahl;
// in .cc: Initialisierung und Definition der
//klassenspezifischen Variablen
int numeriertesObjekt::anzahl = 0;
//Aufruf
cout

Konstanten & Templates
● Klassenspezifische Konstanten
– werden innerhalb der Klassendefinition definiert und initialisiert
– sind klassenspezifisch, auch ohne static-Deklaration
class A {
enum Kaptialanlage {Aktie, Fonds, Festgeld};
static const unsigned int maxZahl=1000;
};
● Klassentemplates Å parametrisierte Datentypen
Bsp.: Stack; i.A. Container
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 46

Operatoren auf Klassen
● Überladen von Operatoren
– entspricht dem Überladen von Funktionen setzt aber Klassen voraus
– Beispiel: += Operator für Strings bedeutet Anfügen
String s1, s2; s1 +=s2; // fügt s2 an s1
– Operatoren können entweder als
» Methoden
ReturnDatentyp operator⊗(Argumentliste) { Code}
» oder als globale Funktionen definiert werden
ReturnDatentyp Klassenname::operator⊗(Argumentliste) { Code}
– alle üblichen Operatoren können überladen werden
» Ausnahme: . .* :: ?:
» es können keine neuen Operatorsymbole definiert werden
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 47

Vererbung: IS-A Hierarchien
● Vererbung ist ein wichtiges Konzept der Abstraktion
– Zusammenfassung von Objekten mit gemeinsamen Eigenschaften Å
Klassifikation von Objekten (sog. is-a Hierarchie)
– Oberklasse: Generalisierung/Abstraktion der Unterklassen
– Unterklasse: Spezialisierung der Oberklasse
– Beispiel: Fahrzeug
Landfahrzeug
Wasserfahrzeug
Luftfahrzeug
PKW LKW Motorboot Segelboot
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 48

Vererbung in C++
● Syntax: class Klassename : public Oberklassenname
● Die Unterklasse (Subclass) erbt von der Oberklasse
(Superclass):
– alle Eigenschaften: die Zustandsvariablen
– das Verhalten: die Methoden
ÅWiederverwendung: nur Abweichungen, Spezialisierungen müssen
berücksichtigt werden
– Beispiele:
» alle Fahrzeuge haben Abmaße: Höhe, Länge, Breite
» Methoden ablegen, ankern, etc. aber nur für Wasserfahrzeuge
sinnvoll
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 49

class Fahrzeug {
Beispiel
public:
Fahrzeug();
Fahrzeug(double, double, double);
void bewegen();
private:
double hoehe, laenge, breite;
};
class Wasserfahrzeug : public Fahrzeug {
public:
void anlegen();
void ankern();
};
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 50

Vererbung in C++ (2)
● Realisierung der Vererbung: Objekt der Subklasse
enthält anonymes Subobjekt der Superklasse
● Klassen in C++ sind Typen Å abgeleitete Klasse
definiert Subtyp
– Objekt der Subklasse ist zuweisungskompatibel zu einem Objekt der
Superklasse:
Fahrzeug A;
Landfahrzeug B;
A = B; // Inhalt des Subobjekts von B wird nach A
kopiert
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 51

Vererbung in C++ (3)
● Initialisierung:
– impliziter Aufruf der Konstruktoren der Superklassen bei Initialisierung
im Rumpf
Landfahrzeug(double h, double l, double b)
{ hoehe=h; laenge=l, breite=b;}
– expliziter Aufruf der Konstruktoren der Superklassen in der
Initialisierungsliste
Landfahrzeug(double h, double l, double b)
: Fahrzeug(h, l, b) { }
– Initialisierung mit einer Initialisierungsliste ist generell vorzuziehen, weil
das Objekt in einem Schritt mit den richtigen Werten initialisiert wird.
Die Initialisierungsliste darf enthalten:
» Elemente der Klasse (außer vererbte)
» Konstruktoraufrufe der Superklassen
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 52

Vererbung: Implementierungshierarchie
● C++ unterstützt nicht nur IS-A Hierarchien sondern auch
beliebige Implementierungshierarchien
Å man spricht allgemeiner von: Ableitung
● Beispiel: Kreis erbt von Punkt, aber Kreis ist kein Punkt!
Punkt
int x
int y
Kreis
int x
int y
int radius
double fläche()
double umfang()
Ellipse
int x
int y
int radius
int radius_y
double fläche()
double umfang()
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 53

Überladen von Methoden -
Polymorphismus
● Generell: Methoden der Superklasse können in der
Subklasse überschrieben werden Å Spezialisierung
Beispiel: für Kreise und Ellipsen wird fläche()
unterschiedlich berechnet
● Achtung: nur virtuelle Methoden der Superklasse in
den Subklassen überschreiben!!
– virtuelle Funktionen garantieren richtige Methodenauflösung zur
Laufzeit, da Typinformation über das Objekt mitgegeben wird
● Achtung: bei unstimmiger Signatur wird auf Methoden
der Superklasse durchgegriffen (wenn dort vorhanden)!
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 54

class A {
public: double foo() {return
0;};
};
class B : public A {
public: double foo() {return
1;};
};
A a;
B b;
A *ptr;
ptr = &a;
cout foo(); // Ausgabe: 0
ptr = &b;
cout foo(); // Ausgabe: 0
Beispiel
class A {
public: virtual double foo()
{return 0;};
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 55
};
class B : public A {
public: double foo() {return
1;};
};
A a;
B b;
A *ptr;
ptr = &a;
cout foo();
ptr = &b;
cout foo();
// Ausgabe: 0
// Ausgabe: 1

Zugriffsschutz
● public und private Deklaration der Superklasse gilt
auch für Objekte der Subklasse
– Zugriffsdeklaration wird mit vererbt
– Schutz der Kapselung: private Members sind in einer abgeleiteten
Klasse nicht zugreifbar
● Neue Zugriffspolitik: protected Members
– protected Members sind in der eigenen und in (public) abgeleiteten
Klassen zugreifbar; sonst wie private
● Spezialfälle: protected und public Vererbung
– Vererbung der Implementierung, aber nicht der Schnittstelle
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 56

Zugriffsschutz (2)
● Spezialfälle: protected und private Vererbung
– Wie werden die public und protected Members vererbt?
– als protected: class A : protected B {};
– als private: class A: private B {};
ÅVererbung der Implementierung, aber nicht der Schnittstelle
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 57

Mehrfachvererbung
● Mehrfachvererbung bietet mehr Flexibilität bei der
Modellierung
Fahrzeug
● Beispiel:
Landfahrzeug
Wasserfahrzeug
Amphibienfahrzeug
● In C++: Angabe mehrerer Superklassen
– Subklasse erbt alle Members (Zustandsvariablen & Methoden) aller
Superklasse
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 58

Mehrfachvererbung (2)
● Probleme: Namenskonflikte und Mehrdeutigkeiten
– Namenskonflikte: explizite Angabe der Basisklasse erforderlich
– Mehrfache Erzeugung von Subobjekten der gleichen Basisklasse (z.B.
Fahrzeug)
Lösung: virtuelle Basisklassen
class Landfahrzeug : virtual public Fahrzeug {...};
class Wasserfahrzeug : virtual public Fahrzeug {...};
class Amphibienfahrzeug : public Landfahrzeug, public
Wasserfahrzeug {...};
● Vergleich zu Java:
– keine Mehrfachvererbung aber Interfaces Å Vorteile der
Mehrfachvererbung ohne deren Probleme
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 59

● Abstrakte Klassen
Abstrakte Klassen
– enthalten sehr allgemeinen (oft nicht veränderbaren) Code
– dienen nur als Superklassen der Vererbungshierarchie
Å es werden keine Objekte der Klasse erzeugt
● Abstrakte Klassen über rein virtuelle Methoden
– rein virtuelle Methode:
» i.A. keinen Definitionsteil und Zusatz: „=0“
Beispiel:
virtual int rein_virtuell(int, int) =0;
– konkrete Klassen (d.h. Klassen für die Objekte angelegt werden)
müssen Implementierung für die virtuellen Methoden bereitstellen
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 60

Exkurs: IS-A vs. PART-OF
● IS-A: A ist eine Spezialisierung von B Å Vererbung
class A : public B { };
– Members von B sind Members von A!
● PART-OF: A enthält B Å A enthält B als Komponente
class A {
B b;
};
– A kann Schnittstelle von B benutzen
© 2000 Dr. Volker Markl Vorlesung Praxis der Softwareentwicklung - Teil 2: C++ 61