Question

In the trivial example inheritance hierarchy:

class Food
{
    virtual ~Food();
};

class Fruit : public Food
{
    virtual ~Fruit();
};

class Apple: public Fruit
{
    virtual ~Apple();
}

class Vegetable: public Food
{
    virtual ~Vegetable();
}

I wish to create a method that can clone an object from its subclass or baseclass instance:

Apple* apple1 = new Apple();
Apple* clone1 = apple1->clone();

Food* food1 = apple1;
Apple* clone2 = food1->clone();

I see a few possible solutions to the problem:

• Use polymorphism to create a virtual function that is explicitly defined for each subclass.

• Use a templated factory method to take an instance of a class and the type of the subclass to create the new instance.

• Register an id with each class and subclass that is stored elsewhere to lookup which subclass to create on calling a baseclass clone function.

None of these seem ideal, but I’m leaning more towards the third solution as it simplifies calling the clone function without requiring a definition to be written for every subclasses (for which there will be a lot).

However, I’m very much open to any suggestions, are there better ways of doing this?

Answer 1

You can use the CRTP to automatically implement a Clone method.

template<typename T, typename Derive> class CloneImpl : public Derive {
public:
    virtual Derive* clone() {
        return new T(static_cast<const T&>(*this));
    }
};
class Food {
public:
    virtual Food* clone() = 0;
    virtual ~Food() {}
};
class Fruit : public Food {
};
class Dairy : public Food {
};
class Apple : public CloneImpl<Apple, Fruit> {
};
class Banana : public CloneImpl<Banana, Fruit> {
};
class Cheese : public CloneImpl<Cheese, Dairy> {
};
class Milk : public CloneImpl<Milk, Dairy> {
};

In this case, you can always call Clone() to copy the current object with a fresh allocation on the heap and you don’t need to implement it again in any class. Of course, if your Clone semantics need to be different, then you can just alter the function.

Not only can the CRTP implement clone() for you, it can even do it between different inheritance hierarchies.