Vererbung - Verständnisfrage

Hey Leute!

Ich habe da eine Frage bezüglich der Vererbung:

class BaseClass
{
public:
    BaseClass()
    : data(0)
    {
       //...
    }
protected:
int data
} ;

class DerivedClass : public BaseClass
{
public:
    DerivedClass()
    : data2(0)
    {
       //...
    }
private:
    int data2 ;
};

Ich hoffe, dass ich jetzt keine Fehler beim Code habe. Sollte alles stimmen, meine Frage lautet, wenn ich jetzt ein Objekt erstelle

DerivedClass Objekt ;

Wird auch implizit der Konstruktor der Basisklasse aufgerufen?

Ich bedanke mich im voraus und hoffe, dass ihr meine Frage verstanden habt.

Grüße Michi

Nexus

Ja. Wenn du keinen expliziten Konstruktor angibst, wird der Standardkonstruktor aufgerufen. Wenn die Basisklasse keinen solchen besitzt, musst du selbst einen angeben. Das kannst du in der Initialisierungsliste erledigen:

class BaseClass
{
    public:
        BaseClass(int i)
        : i(i)
        {
        }
    private:
        int i;
};

class DerivedClass : public BaseClass
{
    public:
        DerivedClass(int i, double d)
        : BaseClass(i) // <- Basisklassenkonstruktoraufruf
        , d(d)
        {
        }
    private:
        double d;
};

Hallo Nexus,

vielen Dank für deine Antwort
Also dann hat sich das mit der Konstruktorfrage erledigt. Danke.

Beim Betrachten deines Codes ist mir jetzt aber was aufgefallen.
Wieso benutzt du in der BaseClass ein >private< statt einem >protected< ?

Ich habe das so verstanden, dass wenn man die Attribute weitervererben will sie als protected markieren muss. Könntest du mir das vielleicht noch erklären ?

Grüße Michi

Nexus

Michi94 schrieb:

Beim Betrachten deines Codes ist mir jetzt aber was aufgefallen.
Wieso benutzt du in der BaseClass ein >private< statt einem >protected< ?

Ich habe das so verstanden, dass wenn man die Attribute weitervererben will sie als protected markieren muss. Könntest du mir das vielleicht noch erklären ?

Sicher. Grundsätzlich versuche ich, die Sichtbarkeit von Membervariablen und -funktionen soweit wie möglich einzuschränken. Die öffentliche Schnittstelle ( public -Bereich) soll klein sein, im Idealfall werden Funktionen als global deklariert, welche keinen direkten Zugriff auf private Member benötigen.

Im Normalfall hat man für die einzelnen Variablen auch Getter- und Setter (sofern damit Eigenschaften des Objekts repräsentiert werden). Das heisst, BaseClass könnte folgende öffentliche Methoden besitzen:

void SetI(int i);
int GetI() const;

Dadurch, dass man die Variable i privat macht, hat man keinen Zugriff mehr von ausserhalb, auch nicht in abgeleiteten Klassen. Man muss also die beiden Get- und Set-Methoden verwenden. Die Kapselung wird auf diese Weise erhöht. Denn je weniger Funktionen direkten Zugriff haben, desto mehr kannst du diesen Zugriff kontrollieren, lokal beschränken und Fehler vermeiden. Beim Debugging kannst du zum Beispiel eine Ausgabe in die Schnittstellen einbauen und somit alle Lese- und Schreibzugriffe auf die Variable mitloggen.

Verstehe, jetzt habe ich was dazu gelernt!
Vielen Dank Nexus für deine Hilfsbereitschaft!