Re: Covariant return types doesn't work (with g++ 4.1.2)

mr.xiaofan.li@gmail.com wrote:


.... snip code along these lines:

     struct base {
         virtual ~base() { }
         virtual base* cut() { return new base; }
     };

     struct derived: base {
         virtual derived* cut() { return new derived; }
     };

The covariant return type of the cut() method allows the derived class
to override the method, even though it actually returns a different,
more specialized static type. If you were not allowed to return a
covariant type, then derived::cut() would have to return a
pointer-to-base, even when the method was invoked directly on an object
of derived type. In other words, you would have to write code like this:

    derived d;
    derived* pd = static_cast<derived*>(pd->cut());

Thanks to the covariant return type, you can write much cleaner code:

    derived d;
    derived* pd = pd->cut();

In your example, your client code looked something like this:

     int main() {
         base* b = new derived();
         derived* d = b->cut(); // error
     }

The problem here is that you have told the compiler to forget the
dynamic type of the first dynamically allocated object, but you have
then tried to rely on knowledge of that type. Leon pointed out that you
can tell the compiler that you know what you're doing by down-casting
the pointer; however, Alf wisely suggested that doing so defeats the
purpose of using a language like C++.

If you allocate an object of derived type, and you will later need to
know that it is of derived type, then it is generally worth the effort
to make sure the compiler knows it, too. If you feel the need for a
cast, then step away from the computer for a little while; try to think
of a way to explain to the compiler, in standard C++, that what you are
doing is safe, so that you do not need the cast.