It doesn’t, however, provide covariancy. In this context, “covariant” means that if have an object whose static (aka compile-time) type is Derived, you should be able to call clone() on it and get back a Derived*, not a Base*.

Doing this is simple if you build each class by hand, but it gets trick with templates because the compiler does not know about the inheritance relationship between Base and Derived when it is instantiating Cloneable<Base, Derived>, so it won’t let you have Cloneable::clone() return a Derived*, which is what you would need to have covariancy, because it doesn’t know that that is legal.

Try changing the return type of Cloneable::clone() to Derived*, in your example and see how the compiler complains.

template <typename Derived, typename Base>
class cloneable : public Base
{
public:
    Base* clone() const
    {
        return new Derived(static_cast<const Derived&>(*this));
    }
};

class graphic
{
public:
    graphic(const graphic& rhs)
    {
    }

    virtual graphic* clone() const = 0;
};

class rectangle : public cloneable<rectangle, graphic>
{
public:
    rectangle()
      : cloneable<rectangle, graphic>(*this)
    {
    }

    rectangle(const rectangle& rhs)
      : cloneable<rectangle, graphic>(rhs)
    {
    }
};

class square : public cloneable<square, rectangle>
{
public:
    square()
      : cloneable<square, rectangle>(*this)
    {
    }

    square(const square& rhs)
      : cloneable<square, rectangle>(rhs)
    {
    }
};

int main()
{
    graphic* r = new rectangle;
    graphic* rc = r->clone();

    graphic* s = new square;
    graphic* sc = s->clone();

    delete r;
    delete rc;
    delete s;
    delete sc;

    return 0;
}

Hope this helps,

Matthias

But wouldn’t it be possible to keep covariance by simply adding a second
template parameter with the base type to the cloneable class template?

Here is an example taken from [1]:

template <typename Derived, typename Base>
class clonable : public Base
{
public:
    Base* clone() const
    {
        return new Derived(static_cast<const Derived&>(*this));
    }
}

class graphic
{
public:
    virtual graphic* clone() const = 0;
};

class rectangle : public cloneable<rectangle, graphic>
{
public:
    rectangle(const rectangle &);
    ...
}; 

class ellipse : public cloneable<ellipse, graphic>
{
public:
    ellipse(const ellipse &);
    ...
};

Another benefit is that it removes redundancy in the class inheritance
definition. That is,

class Derived : public Base, public Cloneable<Base, Derived>

becomes

class Derived : public Base, public Cloneable<Base, Derived

in your example.

[1] http://www.two-sdg.demon.co.uk/curbralan/papers/accu/CloneAlone.pdf