Virtual call w destruktorze klasy bazowej

Czy ktoś może powiedzieć dlaczego to co jest niżej nie działa tak jak powinno?

#include <cstdio>

class CBase
{
public:
	CBase()
	{
		printf("CBase::CBase()\n");
	}
	virtual ~CBase()
	{
		printf("CBase::~CBase()\n");
		this->Destroy();
	}
	virtual void Destroy()
	{
		printf("CBase::Destroy()\n");
	}
};

class CChild : public CBase
{
public:
	CChild()
	{
		printf("CChild::CChild()\n");
	}
	virtual ~CChild()
	{
		printf("CChild::~CChild()\n");
	}
	virtual void Destroy()
	{
		printf("CChild::Destroy()\n");
	}
};

int main()
{
	printf("a\n");
	CChild a;
	printf("b\n");
	CBase* b = new CChild;
	delete b;
	return 0;
}

Logicznie rzecz biorąc powinno się wykonać Destroy z klasy CChild, ale tak się nie dzieje:

http://ideone.com/LI7GPK

Zachowanie jest niezdefiniowane.

At the point a class destructor is run, all subclass destructors have already been run. It would not be valid to call a virtual method defined by a subclass, for which its destructor has already run.

Rule of dumb(thumb?): don't call virtuals in constructors & destructors.

//EDIT: Do twojego problemu użyj shared ptr z własnym deleterem (ten konstruktor:)

template< class Y, class Deleter >
shared_ptr( std::unique_ptr<Y,Deleter>&& r );

Jednak, jeśli chciałbyś mi zaufać, to dużo lepszym pomysłem jest trzymanie takich rzeczy w stanie biernym - niech odpowiedni menadżer tym zarządza, a dla wyspecjalizowanych menadżerów możesz zrobić adapter(most, lub maszynę stanów, ją też da się upchać), który pozwoli Ci przełączać oGL/D3D w locie.

@spartanPAGE zachowanie jest w pełni zdefiniowane. Za Biblią:

§12.7 [class.cdtor]/7 napisał(a)

Member functions, including virtual functions (10.3), can be called during construction or destruction (12.6.2). When a virtual function is called directly or indirectly from a constructor or from a destructor, including during the construction or destruction of the class’s non-static data members, and the object to which the call applies is the object (call it x) under construction or destruction, the function called is the final overrider in the constructor’s or destructor’s class and not one overriding it in a more-derived class.

Inaczej mówiąc, zostanie wywołana funkcja dla istniejącego obiektu najniżej w hierarchii dziedziczenia. Przykład: http://melpon.org/wandbox/permlink/mMT79u0t4KK4oKkm

Gdy miałem ten problem to rozwiązałem go poprzez utworzenie szablonu klasy, którą umieszczałem na końcu hierarchii dziedziczenia, która w destruktorze wykonywała odpowiednie procedury czyszczące. Wymaga to jednak pewnej systematyczności w tworzeniu obiektów.

struct Interface
{
	virtual ~Interface(){
		DBG("Interface::~Interface()");
	}

	virtual void foo() const = 0;

protected:
	Interface(){}

	void cleanup(){
		DBG("Interface::cleanup()");
	}
};

struct Impl : Interface
{
	virtual void foo() const override {
		DBG("Impl::foo()");
	}

	virtual ~Impl(){
		DBG("Impl::~Impl()");
	}
};

template <typename T>
struct InterfaceCleaner : T
{
	virtual ~InterfaceCleaner(){
		DBG("InterfaceCleaner::~InterfaceCleaner()");
		this->Interface::cleanup();
	}
};

http://melpon.org/wandbox/permlink/Lx2qgyDSmhX6MesR

W przypadku OPa wystarczy jednak std::shared_ptr, a jeśli wydajność jest tak niesamowicie istotna, to może boost::intrusive_ptr? Ewentualnie może EASTL, albo jakieś autorskie rozwiązanie?

Obejście problemu: http://www.aristeia.com/EC3E/3E_item9.pdf
(fragment "Effective C++", Scott Meyers)

Przykład pokazuje obejście dla konstruktora, ale raczej nie będzie problemu z zamianą tego na wersję z destruktorem.

delete a
CChild::~CChild()
CBase::~CBase()
CBase::Destroy()

Kiedy już zakończył się destruktor ~CChild(), CChild-owa część obiektu została zniszczona. Nie może się wykonać metoda wirtualna klasy CChild, bo ta klasa w obiekcie już nie istnieje. (metoda mogłaby odwoływać się do pól klasy pochodnej które już zostały zniszczone)

Podobny efekt się dzieje w konstruktorze: w konstr. bazowym nie wykona się metoda wirtualna klasy pochodnej, bo konstruktor pochodnej nie był wykonany, więc pola do których metoda virt. mogłaby się odwoływać nie zostały jeszcze skonstruowane.

Albo prościej: nie wykona się metoda wirtualna klasy, której konstruktor jeszcze nie był wywołany, albo której destruktor już się wykonał.

http://melpon.org/wandbox/permlink/XjCr6q9fQba4aloC

ten compile error powinien wszystko wyjaśnić