Funktion der abgeleiteten Klasse innerhalb der Basisklasse aufrufen?

Jetzt verstehe ich, was du damit meinst... Es könnte eine Endlosrekursion entstehen.

LordJaxom schrieb:

Du kannst aber mit einer Forward-Deklaration einen Zeiger oder eine Referenz auf ein Element der abgeleiteten Klasse halten.

Meinst du damit einen Funktionszeiger, der auf den Klassenmember der abgel. Klasse zeigt? Das mit der Forward-Declaration ist mir nicht so geläufig, könntest du mir dazu bitte anhand des vorigen Codes ein Beispiel geben?

ghorst

nein, er meint so etwas:

class foo;

class bar{
[...]
  foo * zeiger;
};

class foo : public bar{
[...]
};

das sollte funktionieren. danach kannst du unterhalb der beiden definitionen in den funktionen von bar foo ganz normal verwenden.

Hm, danke, ich verstehe zwar was du meinst, aber angewendet auf mein Beispiel möchte das ganze leider trotzdem nicht funktionieren.

So sieht das jetzt aus:

class AbgelKlasse;
class Basisklasse
{
	private:
		AbgelKlasse *derived;

	public:
		void RufeDerivedFuncAuf ();
};

Und was soll ich jetzt mit dem *derived Zeiger anfangen? Ich muss die Klasseninstanz erst auf dem Heap anlegen, per new, was aber auch nichts ändert an dem ganzen Problem. Wenn ich nun die Funktion der abgeleiteten Klasse aufrufen möchte, mache ich das so:

// Wenn das Objekt zuvor per new auf dem Heap angelegt wurde, klappt es so trotzdem nicht:
derived->TestFunc (); 

//Und so auch nicht:
TestFunc ();

Weist du eine Lösung?

Keiner mehr ne Idee?

DrGreenthumb

meinst du sowas?

void RufeDerivedFuncAuf()
{
    if(Derived* d = dynamic_cast<Derived*>(this))
        d->func();
}

Ich weis es ja nichtmal, sonst wär's ja kein Problem. Deine Lösung klappt so aber leider nicht.

DrGreenthumb

wie soll dir hier jemand helfen wenn nicht mal du weißt was du willst?

Außerdem ist "klappt nicht" keine ausreichende Fehlerbeschreibung.

ghorst

Fragender2 schrieb:

Weist du eine Lösung?

wenn ich wüsste, was nicht geht: vllt.

ansonsten fällt mir gerade auf, das sollte man natürlich nicht im konstruktor machen. das würde zu einer rekursiven erzeugung von derived-objekten führen. also wenn du das kindobjekt erzeugen und benutzen willst: nur in virtuellen funktionen, die du in derived überschreibst.

Außerdem ist "klappt nicht" keine ausreichende Fehlerbeschreibung.

Öhm, ich dachte, ich muss euch nicht alles zweimal durchkauen, aber gut. Ich habe bereits in meinem ersten Posts gesagt, welche Fehlermeldung der Compiler bringt, und ich habe dazu ein Codebeispiel geliefert (an dem sich fast keiner bedient). Zudem habe ich auch noch die Projektdateien hochgeladen, damit jeder selber sehen kann, um was es sich genau handelt.

ghorst

weißt du, dass problem ist, wenn du die forward-deklaration richtig durchgeführt hast, ist deine im anfangspost beschriebene fehlermeldung nett ausgedrückt mehr als unwahrscheinlich.

die variante, die DrGreenthumb gepostet hat, bezieht sich darauf, dass du, wenn du ein abgeleitetes objekt hast, dieses eine andere funktionalität in der mutterklasse besitzt als es die mutterklasse würde. deine fehlerbeschreibung zu seiner erklärung ist wirklich dürftige.

warum keiner deinen code nutzt? die antwort ist recht einfach: die meisten haben keine lust soviel code zu verändern. ich auch nicht, daher kriegst du verkürzte stücke code, die beschreiben, wie es funktionieren kann (diese codestücke kann man nebenbei auch recyclen...).

hustbaer

@Fragender2:
Was versuchst du überhaupt zu machen?
Für sowas verwendet man normalerweise virtuelle Funktionen oder das curiously recurring template pattern.

virtuelle Funktionen :

class base
{
public:
    virtual void foo() = 0;
    void bar()
    {
        printf("base::bar\n");
        foo(); // von 'derived' implementiert
    }
};

class derived : public base
{
public:
    virtual void foo()
    {
        printf("derived::foo\n");
    }
};

int main()
{
    derived d;
    d.bar();
}

curiously recurring template pattern:

template <class D> class base
{
public:
    void bar()
    {
        printf("base::bar\n");
        static_cast<D*>(this)->D::foo(); // D::foo aufrufen
    }
};

class derived : public base<derived>
{
public:
    void foo()
    {
        printf("derived::foo\n");
    }
};

int main()
{
    derived d;
    d.bar();
}