Programmieren, Algorithmen und Datenstrukturen 2 (Vorlesung 5)

Destruktor

• enthält Freigabe dynamischer Speicher (delete)
• genutzt um Objekte zu löschen
• Reihenfolge:
  1. Abgleitete Klasse
  2. Member Objekte
  3. Basisklasse

Konstruktion

• Reihenfolge:
  1. Basisklasse
  2. Member-Objekte
  3. Abgleitete Klasse

Klassendiagramm

• Basisklasse steht an der Spitze des Pfeils

Klasse

• Die Initialisierung bzw. Zerstörung eines Objekts läuft nicht nach den Initialisierern, sondern nach der Reihenfolge innerhalb der Klasse

Virtuelle Methoden

• Deklaration und Definition in der Basisklasse
• „Überschreibung“ in abgeleiteten Klassen != Überladen
• Überschreiben = gleiche Argumente / Signatur und gleicher Name
• Wird genutzt um Methoden neue Funktionen zu verweisen
• Schlüsselwort = „virtual“
• Virtual wird nur in der Basisklasse aufgeführt (d.h. die abgeleiteten Klassen dürfen überschreiben)
• Bsp.:
  • virtual void print( ) const;

	void employee::print_list( ) {
	for( employee* p = list; p; p = p->next )
	{
		p->print( );
	}

• Das Beispiel durchläuft alle Employees, aber greift dabei auf die virtuelle print Methode gemäß des jeweiligen Typs zu.
• Direkter Zugriff auf die jeweilige Methode ist über den Gültigkeits-Auflösungs-Operator möglich
• Eine virtuelle Methode muss für die Klasse, in der sie das erste Mal deklariert wurde, auch definiert werden

Abstrakte Klassen

• Klasse mit min. 1 reiner virtuellen Methode
• entweder durch = 0 initialisiert ( Beispiel ) oder alle Konstruktoren = protected
• können keine Objekte erzeugen
• Methoden lassen sich meist nicht richtig definieren
• nur als Basisklasse gedacht ( Rohform für abgeleitete Klassen )
• Klassisches Beispiel sind „Shapes“
• Abgeleitete Klassen von abstrakten Basisklasse sind wieder abgeleitet, solange die rein virtuellen Methoden nicht vollständig überschrieben wurden ( schichtweise möglich )

class X {
	public:
		virtual void a( ) = 0; // rein virtuelle Methode
		virtual void b( ) = 0; // rein virtuelle Methode
	};

	class Y : public X { void a( ); }; // überschreibt X::a -> a ist nicht mehr rein virtuell

	class Z : public Y { void b( ); }; // überschreibt X::b -> erst jetzt sind a und b nicht mehr rein virtuell

	X obj1; // Fehler: Deklaration eines Objekts der abstrakten Klasse X
	Y obj2; // Fehler: Deklaration eines Objekts der abstrakten Klasse Y
	Z obj3; // ok

Kapselung

• public (+) Alle
• private (-) Eigenen Klasse
• protected (#) Eigene Klasse und public abgeleitete Klassen

Klassenvererbung

• class A : public B { /*…*/ }; // …
• class A : protected B { /*…*/ }; // …
• class A : private B { /*…*/ }; // über B kann nicht mehr auf A zugegriffen werden