The best way to implement cloneable c++ classes?

Question

I have seen solutions (including in this site) to the problem of having to implement a clone method in a class, so it returns a heap-allocated clone of itself even if we only have the Baseclass.

The problem come up when you have to implement in a lot of classes the same method again and again, and I remember a way of doing this when you only have to inherit from a template class (name it Cloneable) so it implements it, but the way i'm trying to do it doesn't work:

template<typename T, typename B> class Cloneable{
public:
    B* clone(){return new T(*this);}
};

class Bottom {
public:
    virtual void sayhi() = 0;
    virtual Bottom* clone() = 0;
};

class Middle: public Cloneable<Middle, Bottom>, public Bottom {
public:
    void sayhi() override {cout << "Hi from the Middle" << endl;}
};

//class Top: public Middle ...?

int main() {
    Bottom* b1 = new Middle();
    b1->sayhi();
    delete b1;
}

I remember that the person that showed this to me actually did it with just one argument in Cloneable, but anyways, i would thank any way that you can imagine of doing this.

you are using `Middle` before its definition in template parameter and anything that inherits from a abstract class should override the functions in abstract class else the child will be absract as well — IcanCode, Jan 20 '22 at 14:24
There is no way to do what you want. First, from `Cloneable` point of view, `*this` is `Cloneable&`, so `new T(*this)` expects a constructor taking a `Cloneable&`, not a `Middle&`, or whatever. Second, having `clone` in `Cloneable` does not "implement" the virtual `clone` from `Bottom`. In languages such as Java, you could do this, but this is not possible in C++. — Holt, Jan 20 '22 at 14:46
"you have to implement in a lot of classes the same method again and again": why not put them in the base class ? — , Jan 20 '22 at 15:13
@YvesDaoust because the base class doesn't know what type to `new` — Caleth, Jan 20 '22 at 15:34
How is that solved by moving the functions to the derived classes ??? — , Jan 20 '22 at 15:37

Serge Ballesta · Accepted Answer · 2022-01-20T15:24:53.150

6

You could use the Curious Recurring Template Pattern where a derived class actually derives from an instanciation of it base class depending on itself. Demo:

#include <iostream>

template<typename T>
class Clonable {
public:
    T* clone() {
        return new T { * static_cast<T *>(this)};
    }
};

template<class T>
class Base : public Clonable<T> {
public:
    int x = 2;

    virtual ~Base() {}
};

class Derived : public Base<Derived> {
public:
    int y = 3;
};

int main() {
    Base<Derived> *d = new Derived;

    static_cast<Derived *>(d)->y = 6;

    Derived *c = d.clone();  // we are even cloning from a Base *!
    std::cout << c->x << ' ' << c->y << '\n';
    delete c;
    delete d;
}

It compiles with no warning and correctly outputs 2 6, proving that no slicing occurred.

edited Jan 20 '22 at 15:24

answered Jan 20 '22 at 14:52

Serge Ballesta

143,923
11
122
252

You beat me to it for crtp, although I was just going to comment with this link to gotw: https://herbsutter.com/2019/10/03/gotw-ish-solution-the-clonable-pattern/ – stefaanv Jan 20 '22 at 14:56
2

In your main, `Derived d;` should be `Base d* = new Derived;` and the `Base *c = d->clone();` should still give a Derived. – stefaanv Jan 20 '22 at 14:58
That is exactly what i'm looking for! – Jonnas Kaf Jan 20 '22 at 15:00
@stefaanv: Great! I will improve my post with that... – Serge Ballesta Jan 20 '22 at 15:11
1

The issue with this is now `Base` is a template, and isn't polymorphic – Caleth Jan 20 '22 at 15:17
@SergeBallesta: I tried it myself and I'm not convinced anymore. BTW `Base* d = ...` should be `Base* d = ...` which makes it less useful. – stefaanv Jan 20 '22 at 15:17
@Caleth: My bad, I forgot to write `Base`. Fixed (and now tested ;-) ) – Serge Ballesta Jan 20 '22 at 15:24

score 2 · Answer 2 · answered Jan 20 '22 at 15:28

Your Cloneable is missing a cast. this is a Cloneable *, it needs to be cast to T * to be passed to the copy constructor.

template<typename T, typename B> class Cloneable : public B
{
public:
    B* clone() override { return new T(*static_cast<T*>(this)); }
};

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

class Derived : public Cloneable<Derived, Base>
{
};

See it live

This doesn't stop someone from further subclassing Derived, and forgetting to reimplement clone for that grandchild class.

class Oops : public Derived {};

int main() {
    Oops o;
    Base * pb = o.clone();
    assert(typeid(*pb) != typeid(o));
}

The best way to implement cloneable c++ classes?

2 Answers2