C++ language: Cloneable classes

I'm working on a Cloneable concept for C++ classes. Here's what I
think it should be like, however it doesn't compile :?

#include <memory>

class CloneableBase
{
public:
    virtual ~CloneableBase() {}
private:
    virtual CloneableBase* doClone() const = 0;
};

template < typename Derived >
class Cloneable : public CloneableBase
{
public:
    typedef std::auto_ptr<Derived> AutoPtr;
    AutoPtr clone() const { return AutoPtr( doClone() ); }
private:
    virtual Derived* doClone() const = 0; // COMPILE ERROR
};

class A : public Cloneable<A>
{
    virtual A* doClone() { return new A( *this ); }
};

int main()
{
    {
       A a;
       A::AutoPtr pa = a.clone();
    }
}

cloneable.cpp:17: error: invalid covariant return type for 'Derived*
Cloneable<Derived>::doClone() const [with Derived = A]'
gcc version 4.2.3 (Gentoo 4.2.3 p1.0)

MSVC.NET 2005 gives a similar error on this..

The C++ standard says (10.3.5)
The return type of an overriding function shall be either identical to
the return type of the
overridden function or covariant with the classes of the functions.

Since Derived = A, it is derived from CloneableBase, through
Cloneable<A>, so Derived is covariant with CloneableBase.

Is my understanding wrong, or is this the compilers' bug, or maybe
it's just the way it is supposed to be, and I misunderstand the C++
standard? I'm also looking forward to comments on design/style.

Regards
Krzysztof Czaiński


-- 
      [ See http://www.gotw.ca/resources/clcm.htm
for info about ]
      [ comp.lang.c++.moderated.    First time posters: Do this! ]