复制构造函数：深度复制抽象类

Question

Suppose I have the following (simplified case):

class Color;

class IColor
{
public: 
    virtual Color getValue(const float u, const float v) const = 0;
};

class Color : public IColor
{
public:
    float r,g,b;
    Color(float ar, float ag, float ab) : r(ar), g(ag), b(ab) {}
    Color getValue(const float u, const float v) const 
    { 
        return Color(r, g, b)
    }
}

class Material
{
private:
    IColor* _color;
public:
    Material();
    Material(const Material& m);
}

Now, is there any way for me to do a deep copy of the abstract IColor in the copy constructor of Material? That is, I want the values of whatever m._color might be (a Color, a Texture) to be copied, not just the pointer to the IColor.

Answer 1

看一下虚拟构造函数的习惯用法

Answer 2

你可以在你的界面中添加一个 clone() 函数。

Answer 3

You'll have to add that code yourself to the Material copy constructor. Then code to free the allocated IColor in your destructor.

You'll also want to add a virtual destructor to IColor.

The only way to do a deep copy automatically would be to store a color directly instead of a pointer to an IColor.

Answer 4

Adding a clone() method to color is probably best, but if you don't have that option, another solution would be to use dynamic_cast to cast IColor* to Color*. Then you can invoke the Color copy constructor.

Answer 5

If you have a "factory like" class that creates Colors for you, you can implement a type erased upcasting copy constructor for the user. In your case, it probably doesn't apply, but when it does I find it more elegant than enforcing a clone function on implementers.

struct IColor {
    /* ... */

    // One way of using this.
    // If you have a "manager" class, then this can be omitted and completely
    // hidden from IColor implementers.
    std::unique_ptr<IColor> clone() const final {
        return cpy_me(this); // upcasts
    }

    // There are other ways to riff around the idea, but the basics are the same.

private:
    friend struct ColorMaker;

    IColor() = default;

    using cpy_callback_t = std::unique_ptr<IColor> (*)(const IColor*);
    cpy_callback_t cpy_me = nullptr;
};

struct ColorMaker {
    template <class T>
    static std::unique_ptr<IColor> make_color() {
        static_assert(std::is_base_of_v<IColor, T>, "bleep bloop, no can do");

        std::unique_ptr<IColor> ret = std::make_unique<T>();

        // Encoding type T into the callback, type-erasing it.
        // IColor implementer only has to implement copy constructor as usual.
        ret.cpy_me = [](const IColor* from) -> std::unique_ptr<IColor> {
            return std::make_unique<T>(*static_cast<const T*>(from));
        };

        return ret;
    }
}