class Base
{ 
public:
    virtual void hallo() { cout << "not ok" << endl; }
};

template<class RC>
class ReflectionInterface 
{
public:
    void hallo() { cout << "ok" << endl; }
};

class Derived : public Base, public ReflectionInterface<Derived>
{
}:

int main()
{
    Base* b = new Derived();
    b->hallo(); // "not ok"

    cin.get();
    return 0;
}

Das problem ist, dass "not ok" rauskommt. Sollte hallo() nicht eigentlich von ReflectionInterface überschrieben werden?
Da dies ja offensichtlich nicht der fall ist, wie könnte ich das ganze so hinbekommen, dass die virtuelle methode in Base von der von der template klasse überschrieben wird?

edit: public Base bei Derived vergessen
edit2: fuuuu, eine geschweifte klammer vergessen.

Der Grund warum du dann nicht die richtige Fehlermeldung bekommst, ist folgender:
ReflectionInterface erbt nicht von Base und überlädt daher nicht die virtuelle Funktion.
Derived hat zwei verschiedene Funktionen Namens hallo, eine virtuelle, von base geerbt, sowie die nichtvirtuelle, von ReflectionInterface geerbt. Du könntest daher von Derived aus hallo nicht aufrufen, ohne es genauer zu qualifizieren (ein übliches Problem bei Mehrfachvererbung).

Wenn du allerdings ein Derived über einen Base-Pointer ansprichst wie hier, ist ganz klar was passiert: der statische Typ des Pointers ist Base, daher wird Base::hallo aufgerufen, bzw. da dies virtuell ist, eventuelle Überladungen in abgeleiteten Klassen - Derived überlädt hallo() aber nicht, und es wird Base::hallo() aufgerufen.

Ich vermute mal dass du die Vererbung falsch benutzt und eigentlich ReflectionInterface von Base ableiten wolltest und Derived nur vom ReflectionInterface, dann klappts auch mit dem "ok".

class Base
{
public:
    virtual void hallo() { cout << "not ok" << endl; }
};

template<class RC>
class ReflectionInterface : public Base
{
public:
    void hallo() { cout << "ok" << endl; }
};

class Derived : public ReflectionInterface<Derived>
{
};

int main()
{
    Base* b = new Derived();
    b->hallo(); // "not ok"
}

Beachte, ich habe das ": public Base" bei Derived entfernt und bei ReflectionInterface hingepackt.

Noch ein Tipp: Versuche polymorphe Klassen, die nur als Basis benutzt werden sollen, abstrakt zu machen. Statt

virtual void hallo() { cout << "not ok" << endl; }

hätte man schreiben können:

virtual void hallo() = 0;

Damit wird Base abstrakt und man kann dadurch so einige Fehlerquellen ausschließen.

kk

EDIT: die methode guckt soaus: virtual PyObject* Py_GetInstance() = 0;
PyObject* ist ein zeiger auf eine struct.

aaaaaha, sehr interessant: wenn ich eine virtuelle methode habe, die eine struct zurückgibt, dann erscheint bei mir ein unaufgelöstes symbol!
Kennt das problem jemand?

Das hat nichts damit zu tun, ob die Methode virtuell ist oder was sie zurück gibt... der Fehler liegt woanders. Code bitte (möglichst kurz, aber compilierfähig und sollte den Fehler ergeben)

MfG