c++ - 对象的分离构造和克隆

Question

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

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

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

我想了一段时间，但想不出任何方法让外部函数/对象访问私有(private)成员(无需暴力破解)。这是我认为可行的一个例子:

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 无法访问其嵌套基类的父类的 protected 成员(哇，这是一个句子。)

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

编辑

睡了一夜好觉后，我决定使用标志来控制数据的复制。它与 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;
}

这为类添加了很多代码，但它确实保持了类的清洁和安全。所有的复制都保存在一个地方。 protected 和私有(private)变量保持私有(private)。 API 保持相当简单(<--- 非常重要!)用户仍然可以使用标志创建自定义复制定义。也许我什至可以使用一些 boos 变体魔法来减少代码。不管怎样，如果你有任何其他想法，我仍然愿意听取他们的意见。

Answer 1

您使用嵌套类的方法与使用 friend 大致相同，除了它只是由于嵌套而隐式存在。并且，如果您开始允许外部类或方法出于此复制目的访问私有(private)内部结构，则会鼓励滥用此类访问并绕过公共(public)接口(interface)。

相反，我要建议的是使用标记的构造函数在类中强制执行一致的复制机制:

struct DeepCopy {};
struct ShallowCopy {};
struct MagicCopy {};

class BigThing
{
public:
    BigThing() {}

    BigThing(const BigThing& right);  // Don't implement.

    BigThing(const BigThing& right, DeepCopy);  // Do the deep copy.

    BigThing(const BigThing& right, ShallowCopy);  // Do the shallow copy.

    BigThing(const BigThing& right, MagicCopy);  // Do the magic copy.
};

int main()
{
    BigThing b1;
    BigThing b2(b1, DeepCopy());
    BigThing b3(b1, MagicCopy());
}