covariant return type in override

#include <iostream>
 
class Base
{
public:
    // This version of getThis() returns a pointer to a Base class
    virtual Base* getThis() { std::cout << "called Base::getThis()
"; return this; }
    void printType() { std::cout << "returned a Base
"; }
};
 
class Derived : public Base
{
public:
    // Normally override functions have to return objects of the same type as the base function
    // However, because Derived is derived from Base, it's okay to return Derived* instead of Base*
    virtual Derived* getThis() { std::cout << "called Derived::getThis()
";  return this; }
    void printType() { std::cout << "returned a Derived
"; }
};
 
int main()
{
    Derived d;
    Base *b = &d;
    d.getThis()->printType(); // calls Derived::getThis(), returns a Derived*, calls Derived::printType
    b->getThis()->printType(); // calls Derived::getThis(), returns a Base*, calls Base::printType
}

　Note that some older compilers (e.g. Visual Studio 6) do not support covariant return types.

　One interesting note about covariant return types: C++ can’t dynamically select types, so you’ll always get the type that matches the base version of the function being called.

　In the above example, we first call d.getThis(). Since d is a Derived, this calls Derived::getThis(), which returns a Derived*. This Derived* is then used to call non-virtual function Derived::printType().
　Now the interesting case. We then call b->getThis(). Variable b is a Base pointer to a Derived object. Base::getThis() is virtual function, so this calls Derived::getThis(). Although Derived::getThis() returns a Derived*, because base version of the function returns a Base*, the returned Derived* is downcast to a Base*. And thus, Base::printType() is called.

　In other words, in the above example, you only get a Derived* if you call getThis() with an object that is typed as a Derived object in the first place.

　do not use virtual function in construction and destruction.