分离构造或克隆对象

我有一个非常复杂的类。它在大型数组中有许多不同级别的数据。我在许多不同的上下文中使用这个对象。

问题:我们在传递这个对象时复制它，但是每个点对需要复制的内容和需要删除的内容有不同的要求。结果，代码变得越来越难看，人们以5-6种不同的方式到处复制，从复制构造函数到克隆函数。它已经变得丑陋了。

我想做的:我想以一种外部可扩展的方式解耦对象的构造。如果有人有一次性使用的特殊复制情况，我希望他们能够在相关的文件中创建一个函数或类，然后将其传递给克隆函数。

我已经想了一段时间，但不能想到任何方法有一个外部函数/对象访问私有成员(不强制)。下面是我认为有用的一个例子:

class Dolly
{
public:
    Dolly (int c = 0) : c(c) {}
    struct Cloner
    {
        virtual Dolly* operator()(Dolly const& p) const
            { return new Dolly(p.c + 1); }
    } cloneDeep;
    Dolly* clone();
    Dolly* clone(Cloner const& cloner)
        { return cloner(*this); }
protected:
    int c;
};
class ShallowCloner : public Dolly::Cloner
{
    Dolly* operator()(Dolly const& p) const
        { return new Dolly(p.c + 2); } // Error: cannot access c because its protected
} cloneShallow;

但是派生的ShallowCloner不能访问它嵌套的基类的父类的受保护的成员(哇，这是什么句子啊)

如果你知道任何可能有帮助的解决方案或设计模式，请告诉我。由于

编辑

睡了一个好觉之后，我决定使用标志来控制数据的复制。这与Mark B的答案没有太大的不同，但由于旗标的帮助，从长远来看，代码并不多。下面是我正在思考的一个当前框架(这是一个非常简化的例子):

class Dolly
{
public:
    enum CopyData {
        D1 = 0x01,
        D2 = 0x02,
        D3 = 0x04,
        D4 = 0x08,
        DEEP = D1 | D2 | D3 | D4
    };
    Dolly(int d1 = 0, int d2 = 0, int d3 = 0, int d4 = 0) : 
            d1(d1), d2(d2), d3(d3), d4(d4) {}
    Dolly(Dolly const& cpy, int copyFlags = DEEP) {
        copyDataFrom(cpy, copyFlags);
    }
    Dolly* clone(int copyFlags) {
        return new Dolly(*this, copyFlags);
    }
    void copyDataFrom(Dolly const& cpy, int copyFlags) {
        if (copyFlags & D1) {
            copyD1From(cpy);
        }
        if (copyFlags & D2) {
            copyD2From(cpy);
        }
        if (copyFlags & D3) {
            copyD3From(cpy);
        }
        if (copyFlags & D4) {
            copyD4From(cpy);
        }
    }
    // Note that the real copies are more complex than this
    inline void copyD1From(Dolly const& cpy) { d1 = cpy.d1; }
    inline void copyD2From(Dolly const& cpy) { d2 = cpy.d2; }
    inline void copyD3From(Dolly const& cpy) { d3 = cpy.d3; }
    inline void copyD4From(Dolly const& cpy) { d4 = cpy.d4; }
protected:
    int d1;
    int d2;
    int d3;
    int d4;
};
int main()
{
    Dolly dolly(1,2,3,4);
    //Copy using constructor
    Dolly dolly2(dolly, Dolly::D1 | Dolly::D2);
    //Copy using clone
    Dolly* dolly3 = dolly.clone(Dolly::D3 | Dolly::D4);
    delete dolly3;
    //Copy using copyFrom
    Dolly dolly4;
        // Maybe do stuff here...
    dolly4.copyDataFrom(dolly, Dolly::D1 | Dolly::D3);
   return 0;
}

这给类添加了大量代码，但它确实保持了它的干净和安全。所有的抄本都保存在一个地方。受保护的和私有的变量保持私有。并且API保持相当简单(<——非常重要!)用户仍然可以使用这些标志创建自定义副本定义。也许我甚至可以使用一些boos变体魔法来减少代码。无论如何，如果你有任何其他的想法，我仍然愿意倾听。