habe eine Frage bzgl. Vererbung in C++: Wenn man eine Methode in der Oberklasse deklariert in der Headerdatei, dann braucht man diese doch nicht nochmal in der headerdatei der Unterklasse zu deklarieren oder? Und falls Sie in der Oberklasse mit virtual deklariert wurde dann kann man Sie doch in den Unterklassen verschieden definieren, oder? Vllt. klingt die Frage komisch aber...

Danke im Voraus,

Jenny

Virtuelle Methoden sind auch in den Unterklassen sichtbar, müssen aber im Falle des Überschreibens auch neu deklariert werden. Du kannst ja sogar den Typ leicht abändern (da gibt es spezielle Regeln)

Aber man muss man denn dieselben Methoden in den Headerdateien der Unterklassen neu deklarieren?

Es ist nicht ganz klar, was du meinst... ich glaube, die Antwort auf deine Frage ist nein, aber weil die Frage nicht so klar ist....

Ok. Und wenn ich sie nicht überschreiben will dann brauch ich nicht nochmal deklarieren?

Nein. Wieso auch? Ist doch schon in der Basisklasse deklariert.

Wenn man eine Methode in der Oberklasse deklariert in der Headerdatei, dann braucht man diese doch nicht nochmal in der headerdatei der Unterklasse zu deklarieren oder?

Nur, wenn Überschreiben gewünscht ist.

Und falls Sie in der Oberklasse mit virtual deklariert wurde dann kann man Sie doch in den Unterklassen verschieden definieren, oder?

Wenn Du mit definieren implementieren meinst: Ja, dennoch ist Deklaration in der Unterklasse notwendig. Du kannst hingegen nicht den Rückgabetyp/Parametertypen ändern. Das wäre dann eben eine Funktionsüberladung, s. auch belli.

class Oberklasse
{
public:
    void foo() {/* ... */}
    virtual void bar() {/* ... */}
};

class Unterklasse1 : public Oberklasse
{
};
// Unterklasse1-Instanz enthält nun aufrufbare Methoden foo und bar

void Unterklasse1::foo()
{
    // Nein, so nicht! Deklaration notwendig, aber wäre wegen fehlendem virtual eh widersinnig
}

void Unterklasse1::bar()
{
    // auch das geht nicht, Deklaration in Unterklasse1 fehlt
}

class Unterklasse2 : public Oberklasse
{
public:
    void foo(); // eigentlich unsinnig; Überschreiben geht ja nicht, aber syntaktisch ist Deklaration ok
    virtual void bar(); // notwendig, wenn bar überschrieben werden soll
};

void Unterklasse2::bar()
{
    // Dafür ist Deklaration wie oben notwendig, ist jetzt also in Ordnung
}

Du kannst hingegen nicht den Rückgabetyp/Parametertypen ändern. Das wäre dann eben eine Funktionsüberladung, s. auch belli.

Doch, das geht eben schon

Bsp:

#include <iostream>
#include <ctime>

class Base
{
	int x;
};

class Derive : public Base
{
	int y;
};

// -----------------------------------------------------------------------

class FooBase
{
protected:
	Base * m_inst;

public:
	FooBase()
		: m_inst(new Base)
	{	}

	virtual Base& getInst(Base & b)
	{
		return *this->m_inst;
	}
};

class FooDerive : public FooBase
{
public:
	FooDerive()
	{
		this->m_inst = new Derive;
	}

	virtual Derive& getInst(Derive& de)
	{
		Base * b = this->m_inst;
		Derive * d = static_cast<Derive*>(b);
		return *d;
	}
};

int main()
{
	srand(time(0));
	Base * pb = rand()%2 ? new Base : new Derive;

	FooBase * pfb = rand()%2 ? new FooBase : new FooDerive;

	Base & b = pfb->getInst(*pb);
	Derive & d = static_cast<Derive&>(pfb->getInst(*pb));

	return 0;
}

(Es geht nur um das Ändern der Methodenköpfe und nicht um das Speichermangement!)

Eisflamme schrieb:

Du kannst hingegen nicht den Rückgabetyp/Parametertypen ändern. Das wäre dann eben eine Funktionsüberladung, s. auch belli.

Doch, das geht eben schon

was dann eine Funktionsüberladung ist. pb ist ein Pointer auf Base und somit wird immer FooBase::getInst aufgerufen (welche nicht in FooDerived überschrieben, sondern nur überladen ist).

My Bad