ich möchte innerhalb meiner Basisklasse eine Funktion der von der Basisklasse abgeleiteten Funktion aufrufen, sobald ich aber den Header mit der Klassendeklaration der abgeleiteten Klasse in die Basisklasse inkludieren möchte, wirft mir der VC Compiler folgenden Fehler:

'IoBase': Basisklasse undefiniert

Basisklasse.h

#ifndef _BASISKLASSE_H_
#define _BASISKLASSE_H_

#include <iostream>

// Wenn du den folgenden Include und alle anderen, relevanten Aufrufe auskommentierst,
// verschwinden die Fehlermeldungen.
#include "AbgelKlasse.h"

class Basisklasse
{
	private:
		AbgelKlasse derived;

	public:
		void RufeDerivedFuncAuf ();
};

#endif

Basisklasse.cpp

#include "Basisklasse.h"

void Basisklasse :: RufeDerivedFuncAuf ()
{
	derived.TestFunc (); 
}

AbgelKlasse.h

#ifndef _ABGELKLASSE_H_
#define _ABGELKLASSE_H_

#include "Basisklasse.h"

class AbgelKlasse : public Basisklasse
{
	public:
		void TestFunc ();
};

#endif

AbgelKlasse.cpp

#include "AbgelKlasse.h"

void AbgelKlasse :: TestFunc ()
{
	std::cout << "Aus der Testfunktion" << std::endl;
}

main.cpp

#include "Basisklasse.h"

int main ()
{
	Basisklasse basis;
	basis.RufeDerivedFuncAuf ();
	std::cin.get ();
}

MS VC++ EE 2005 Projektdatei gibt's hier runterzuladen.

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

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?

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.

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?

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

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

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.

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...).

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();
}