class A
{
    public:
        A(){};
        ~A(){};
};

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

class C :
    virtual public B
{
    public:
        C(){};
        void b(){};
};

int main()
{
    A a;
    C c;
    return 0;
};

der compiler von Code::Blocks warnt mich nun das B und C einen virtuellen Destruktor benötigen. Tatsächlich reicht ein virtueller Destruktor bei B aus, aber was mich viel mehr interessiert ist, warum ich überhaupt die Warnung bekomme. Es muss etwas mit der virtual Vererbung zu tun haben, denn wenn ich das virtual weglasse brauche ich das nicht mehr machen. allerdings kann ich bei meinen tatsächlichen klassen dann das virtual nicht weglassen.
Danke schonmal im voraus.

du musst eigentlich bei allen Funktionen (+ Destruktor)
die du Vererben willst ein virtual davor setzen

also eigentlich auch bei ~A()

Gruß Simon

Sie sollten Ihre Aufgaben in OOP lieber allein lösen. Nehmen Sie sich doch einfach ein gutes CPP-Buch, dann klappt es auch mit der Abnahme!

ich rede nicht von virtual funktionen sonder davon das ich A bzw B virtual vererbe.

Der Compiler redet aber von virtuellen Funktionen

Da B eine virtuelle Methode enthält, sollte B auch einen virtuellen Desktruktor enthalten. Ich bin mir sogar ziemlich sicher, dass die Compilermeldung genau das aussagt (class with virtual functions but non-virtual destructor).

Die Begründung wurde schon genannt: Damit ein "delete object" mit decltype(object) == B auch dann definiert ist, wenn object auf ein C zeigt.

wenn ich allerdings den Dtor in A schon virtual mache brauche ich in B keinen mehr einfügen da dieser ja schon den von A erbt und soweit ich weiß das virtual mit vererbt wird. sehe ich das richtig?

Jein, der Destruktor wird nicht vererbt, jedes Objekt hat automatisch einen eigenen Destruktor, auch wenn man ihn nicht angibt. Wenn der Destruktor in der Basisklasse allerdings virtual ist, dann sind auch alle Destruktoren virtual , welche zu einer von der Basisklasse abgeleiteten Klasse gehören. Also auch die automatisch vom Compiler erstellten Destruktoren.

Grüssli

class A
{
    public:
        A(){};
        virtual ~A(){};
};

template<class t>
class B :
	virtual public A
{
	public:
		class BB
		{
			private:
				t b;
			public:
				void bb(){};
		};
};

template<class t>
class D
{
	public:
		t _t;
};

template<class t>
class C :
	virtual private B<t>
{
	private:
	public:
		using B<t>::BB;
		C(){};
		~C(){};
		void c()
		{
			D<typename BB> d; // Fehler, hier muss "typename B<t>::BB" rein, aber warum?
			d._t.bb();
		};
};

gibt es irgendeine möglichkeit die subklasse BB von B in C direkt verfügbar zu machen mit using gehts offensichtlich nicht.

grüße

Gilt auch für "Subklassen".

Grüssli