Question

We have a Base class and a Derived class that derives from Base.

In some other class, we want to have a member of type shared_ptr<Base>.

We cannot use the type Base directly because direct copying like that will rule out subclasses.

However, we still want to “copy” the Base (or subclass) object over upon construction, because we want to rule out the possibility of it being modified.

The classic way to deal with this is to put a virtual member function clone() into the Base class that every subclass of Base can then implement. Every clone() would then just return a “copy” of itself – for example, Derived would return make_shared<Derived>(*this).

The problem with this approach is that this requires every new subclass of Base to implement this clone() function. The code in each clone() is rather boilerplate, and it seems somewhat unnatural to be repeating it all the time.

Any better ways to do this since C++11?

Answer 1

It has always been possible to do this in plain C++:

struct base
{
    virtual ~base () {}
    virtual base* clone () = 0;  
    virtual void foo () = 0;
};

template <typename T>
struct base_impl : base
{
    T* clone () { return new T (*static_cast<T*> (this)); }
};

struct derived : base_impl<derived>
{ 
    void foo () { ... }
};

struct derived2 : base_impl<derived2>
{
    void foo () { ...}
};

etc.

You can improve this with C++11: you can use unique_ptr<base> (but you lose the covariant return type), you can make the destructor of base_impl private and use friend T.

I agree that this is not very flexible in this case but:

• many layered hierarchies are not very common
• clone functions are not very useful
• the design is nevertheless extensible and goes beyond cloning: using templates as a way to automate boilerplate code is used thoroughly in eg. ATL and WTL. Search for “curiously recurring template pattern”.

Another solution. This can probably be improved in various ways, but I think you can’t avoid having two clone functions:

struct base
{
    std::unique_ptr<base> clone () { return std::unique_ptr<base> (do_clone ()); }

private:
    virtual base *do_clone () = 0;
};

template <typename T>
struct base_impl : base
{
    std::unique_ptr<T> clone () 
    {
        return std::unique_ptr<T> (static_cast<T*> (do_clone ()));
    }    

private:
    base *do_clone () { return new T (*static_cast<T*> (this)); }
};