klar, ein Datentyp kann in C++ nicht virtual sein!
Ich habe folgendes Problem (vereinfacht, es gibt mehrere abgeleitete Klassen von A als auch von Basis):

class A
{
public:
	virtual void Func() = 0;
};

class B : public A
{
public:
	void Func();
};

//-------------------------
class Basis
{
protected:
	A m_A;  // <-- Problem
};

class Abgeleitet : public Basis
{
private:
	B m_A;
};

Kann ich in die Klasse Basis eine Instanz von A einbinden? So wie in meinem Code geht das ja nicht, weil A eine virtuelle Funktion hat?!

Ich muss aber voraussetzen, das alle von Basis abgeleiteten Klassen ein von A abgeleitetes Element besitzen. Wie kann ich das machen?

Oder eine andere Methode, es muss doch eine (nicht zu komplizierte) Möglichkeit geben?!

Vllt denke ich auch einfach verkehrt, wer kann mir helfen?

MfG,
XCoder

Dann müsstest du davon auch wieder Objekte erzeugen können.
Von Abstrakten Klassen geht dieses nicht das sie Abstrakt sind sprich man kann dan nur von ihnen erben lassen diese Abstrakte Klassen dienen auch als Schablonen für andere Klassen.

Mfg WIkinger75

Edit: Also eine Instanz von A bekommst du in B nur ein wen A nicht abstrakt ist...

@XCoder++:
Wenn dich nicht stört dass es ein Hack ist, der zwar IMO nicht 100% Standardkonform ist, aber trotzdem auf jedem mir bekannten Compiler funktioniert, könntest du es so machen:

class A
{
public:
    virtual void Func() = 0;
};

class B : public A
{
public:
    void Func();
};

//-------------------------
class Basis
{
protected:
    explicit Basis(A* a) : m_a(a) {}
private:
    A* m_a;
};

class Abgeleitet : public Basis
{
public:
    Abgeleitet() : Basis(&m_b) {}
private:
    B m_b;
};

Das einzig "böse" was hier passiert, ist, dass man einen "Zeiger auf ein noch nicht konstruiertes Objekt" übergibt. Solange der Konstruktor von "Basis" sich diesen Zeiger aber nur merkt, und nicht verwendet, sollte es funktionieren.

class Basis
{
protected:
    explicit Basis(A* a) : m_a(a) {}

    std::auto_ptr<A> m_a;
};

class Abgeleitet : public Basis
{
public:
    Abgeleitet() : Basis(new B) {}
};

Das wäre dann hübsch Standard-Konform.

Und natürlich musst du bei beiden Varianten den Copy-Ctor und Assignment-Operator selbst implementieren.