• Seitenanfang
• Zugriff auf die Vorfahren
• Konstruktoren und Zuweisung
• Mehrfach-
  vererbung

Die Informatik steckt voller schöner Analogien. So hat die objektorientierte Programmierung den Begriff der »Vererbung« eingeführt, wenn eine Klasse von einer anderen Klasse abgeleitet wird und deren Eigenschaften übernimmt. Der Begriff Vererbung hat hier weniger mit dem Testament eines verblichenen Verwandten zu tun als mit den biologischen Regeln, die ein Herr Mendel dankenswerterweise entdeckte. Da meine Kenntnisse in Biologie eher bedauernswert sind, müssen Sie hier auf einen unterhaltsamen Ausflug in die Biologie verzichten. Aber wenn Sie einmal ein Biologie-Buch in die Hände bekommen, werden Sie feststellen, dass sich die mendelschen Regeln sowieso nicht genauso verhalten wie Basisklassen und deren abgeleiteten Klassen. Dennoch kenne ich mindestens einen Biologen, der ein prima Programmierer geworden ist.

Basisklasse

Wiederverwendung des Codes

Spezialisierung

Beispiel

An dieser Stelle steht im Buch die Abbildung "Personenklassen" (abbpersonenerbe)

Damit stellt die Ausgangsklasse Person die Verallgemeinerung dar und jede abgeleitete Klasse eine Spezialisierung. Der Vorteil dieser Technik ist, dass der bestehende Code der Basisklasse nicht noch einmal für die neu geschaffene Klasse geschrieben werden muss. Beispielsweise würde eine Prüffunktion der Adresse, die der Klasse Person hinzugefügt wird, automatisch auch allen anderen Klassen, die direkt oder indirekt von Person abgeleitet wurden, hinzugefügt, ohne dass eine Zeile Code mehr geschrieben werden müsste. Eine Änderung in der Klasse Mitarbeiter würde immer auch auf die Außendienstler durchschlagen. Es gibt aber keine Rückwirkung auf die Geschäftspartner.

»Ist ein«

Beispiel Firma

[Personen]

class Person 
{
public:
    string Name, Adresse, Telefon;
};

class Partner : public Person 
{
public:
    string Kto, BLZ;
};

class Mitarbeiter : public Partner 
{
public:
    string Krankenkasse;
};

class Kunde : public Partner 
{
public:
    string Lieferadresse;
};

class Lieferant : public Partner 
{
public:
    tOffenePosten *Rechnungen;
};

class Aussendienst : public Mitarbeiter 
{
public:
    tBezirk Bezirk;
};

Kompatibilität zur Basisklasse

Person person;
Mitarbeiter mitarbeiter;

    person = mitarbeiter; // ok
    mitarbeiter = person; // das mag der Compiler nicht

Beispiel tDatum

[Feiertag]

class tFeiertag : public tDatum 
{
public:
  char Name[40];
};

    tFeiertag Ostern;
    Ostern.Tag = 25;
    Ostern.Monat = 4;

Anschließend können Sie mit dem Objekt Ostern genauso umgehen wie mit jeder Instanz von tDatum. Die Klasse tFeiertag erbt alle Eigenschaften von tDatum und fügt lediglich die Besonderheiten eines Feiertags hinzu. Ein wichtiger Vorteil besteht darin, dass Sie die Klasse tDatum nicht verändern müssen. Jede Veränderung eines Code-Segments kann zu Fehlern führen. Aus diesem Grund kann es auch sein, dass Sie in größeren Projekten überhaupt keine Berechtigung bekommen, Klassen zu ändern, von denen Sie etwas ableiten wollen. Gerade weil der Anwender der Basisklassen nicht den Code in der Basisklasse anpassen muss, sind Klassenbibliotheken flexibler als Funktionsbibliotheken. Änderungen werden einfach in einer abgeleiteten Klasse durchgeführt.

Zugriff auf die Vorfahren

protected

[protected]

class Basis
{
private:
   int privat;
protected:
   int protect;
public:
   int publik;
};

class Abgelitten : public Basis
{
    void zugriff()
    {
        a = privat;  // Das gibt Ärger!
        a = protect; // Das funktioniert.
        a = publik;  // Das funktioniert sowieso.
    }
};

int main()
{
    Basis myVar;
    a = myVar.privat;  // Das läuft natürlich nicht.
    a = myVar.protect; // Das geht auch nicht.
    a = myVar.publik;  // Das funktioniert.
}

Ändern der Öffentlichkeit

[Ändern der Zugriffsart]

class Basis
{
private:
   int privat;
protected:
   int protect;
public:
   int publik;
};

class Abgelitten : public Basis
{
protected:
   using Basis::publik;
public:
   using Basis::protect;
};

int main()
{
    Abgelitten a;
    b = a.protect;  // O Wunder, es geht!
}

Ein solches Vorgehen werden Sie schon deswegen in der Praxis selten finden, weil es den Eindruck macht, dass beim Design nicht sorgfältig gearbeitet wurde. Es ist also nur als Notlösung zu betrachten, um ungeschickt vergebene Zugriffsrechte durch Ableitung zu korrigieren.

Zugriffsattribute zur Vererbung

Öffentliche Elemente der Basisklasse werden durch privates Ableiten
in der abgeleiteten Klasse privat.

[Privates Ableiten]

class Basis
{
private:
   int privat;
protected:
   int protect;
public:
   int publik;
};

class Abgelitten : Basis // Vorsicht: das ist private!
{
    int f1() { return privat; }  // das geht nicht!
    int f2() { return protect; } // das geht
    int f3() { return publik; }  // das geht
};

int main()
{
    Abgelitten a;
    Basis b;
    i = a.publik;  // Das geht schief!
    i = b.publik;  // Das funktioniert einwandfrei.
    b = a;         // Das funktioniert wieder nicht.
}

Beschränkung

protected

Elemente der Basisklassen

Funktionsaufruf

[Funktionsaufruf der Basisklasse (kasfunc.cpp)]

class tBasis
{
public:
    int TuWas(int a);
};

class tSpezialfall : public tBasis
{
public:
    int TuWas(int a);
};

int tSpezialfall::TuWas(int a)
{
    int altWert = tBasis::TuWas(a);
    ...
    return altWert;
}

Im Beispiel wird die Funktion TuWas() in der Klasse tSpezialfall zunächst die Funktion TuWas() der Klasse tBasis aufrufen und dann die Sonderfälle der abgeleiteten Klasse behandeln.

Konstruktoren und Zuweisung

Kaskadierende Konstruktoren

Parameterunterschiede der Konstruktoren

[Konstruktoraufruf (kaskonstrukt.cpp)]

class tBasis
{
public:
    tBasis(int i); // Kein Standardkonstruktor
};

class tSpezialfall : public tBasis
{
public:
    tSpezialfall() : tBasis(5) // Basiskonstruktor aufrufen
    {
        ...
    }
};

Das Anlegen eines Objekts vom Typ tSpezialfall ruft den Standardkonstruktor auf. Ohne den Initialisierer würde der Compiler den Standardkonstruktor von tBasis aufrufen. Den gibt es allerdings nicht. Durch den Initialisierer wird der Konstruktor mit dem Integer-Parameter explizit aufgerufen, bevor die Initialisierung von tSpezialfall beginnt.

Kopierkonstruktor

tSpezialFall(const tSpezialFall& objekt) :tBasis(objekt)
{
    ...
}

Zuweisungsoperator

tSpezialFall& operator=(const tSpezialFall& objekt)
{
    if (this!=&objekt)
    {
        // Vermeide Selbstkopie!
        tBasis::operator=(objekt);
        // eigene Elemene zuweisen
    }
    return *this;
}

Mehrfachvererbung

Syntax

class Auto : public Motor, public Kutsche
{
    ...
};

Namenskonflikte

class Auto : public Motor, public Kutsche
{
    ...
    a = Motor::Lager;
    ...
    b = Kutsche::Lager;
    ...
};

Umstritten