I got few suggestions for you [color=#3F454B][font=monospace]CBase [/font]class. Disable copy constructor and assignment operator to it. Use only private data members (or use a struct.) It's better to just delete in the destructor instead of calling virtual functions. I'd avoid inheriting implementation.

Although you have a valid point there, I think the wording "virtual functions are not virtual inside constructors and destructors" could be improved, it is somewhat misleading (or even wrong).

The code snippet you posted does not work because it assumes that the base's destructor will call the derived class' virtual function to clean up. This is a well-known pitfall, but the issue is not that virtual functions are not virtual functions, but that the type of object during a constructor or destructor is, well, the actual type with the constructor's name, not some derived class as one might expect (and therefore one should avoid that kind of stuff if possible, just to be sure).

But regardless, virtual functions work perfectly well inside constructors and destructors (though statically resolved, because the compiler knows the exact type at that time), they are just dangerous because a seemingly harmless line of code does not necessarily do what one thinks. But they certainly behave like they should.

If you have e.g.
struct A { A() { v(); }; virtual void v(){}; };
struct B : public A { B() { v(); }; virtual void v(){}; };
struct C : public B { C() { v(); }; virtual void v(){}; };
then A::A will call A::v, B::B will call B::v, and C::C will call C::v, because the type is A inside A::A, and B inside B::B, and so on. It works the same way in destructors.

Assuming that e.g. B::B will call A::v or A::A will call C::v or A::~A will call C::v is just not how C++ works. But regardless, a virtual function that you overload in B behaves like the B version of the function just as it should. It's not like it is just "gone" or replaced with the base class or something else (which is kind of how "virtual functions are not virtual" sounds like).