Question

Supose我有一个包含许多字段的类，和/或不断变化（在开发中），并且它的所有字段都是本机或不一定是POD类型，它们提供了令人满意的复制构造函数，但是一个 - 甚至可能删除或私有化其复制构造函数，但为我提供了根据需要进行复制的方法。
现在假设我需要它拥有自己的复制构造函数我是否必须通过字段副本来编写详尽（耗尽）字段，或者是否有更清洁，更少暴露于错误的方法来实现相同的目标？

插图代码：

class Big {
public :
  Big(Big const & big) : ? { ? }
protected :
  int i1, i2, ... , i50;
  float f1, f2, ... , f50;
  CopyConstructableClass1 c1;
  CopyConstructableClass2 c2;
  ...
  CopyConstructableClass20 c20;
  NonCopyConstructableClass ncc;
};

由于

Answer 1

你可以把讨厌的类包装成你自己设计的一个可识别的可复制类，然后让你的大变化类中的字段成为包装类型而不是原始类型。这样，您只需要在一个地方完成“自定义复制”的工作，然后您可以在其他地方重复使用该逻辑。

遵循单一责任原则，该原则规定每个班级应该只有一个责任，复杂性是由作文构建的。

Answer 2

通常我在这种情况下所做的是将所有可以复制自己的字段放入基类中。比我只有一个字段的派生类，将手动复制。

为了强调这个基类不能在它自己的基础上使用的事实，标记它的析构函数protected是明智的。实际上，它的所有成员都可以。

Answer 3

考虑一些会跳过赋值运算符逻辑的东西。作为一个例子（不是真正的代码）：

template <typename T>
class DontCopyThisField : public T
{
public:
    template <typename... Args>
    DontCopyThisField(Args&&... args):
        T(std::forward<Args>(args)...)
    {
    }

    DontCopyThisField(const DontCopyThisField& from)
    {
    }

    DontCopyThisField(DontCopyThisField&& from):
        T(static_cast<T&&>(from))
    {
    }

    DontCopyThisField& operator=(const T& from)
    {
        T::operator=(from);
        return *this;
    }

    DontCopyThisField& operator=(T&& from)
    {
        T::operator=(std::move(from));
        return *this;
    }

    DontCopyThisField& operator=(const DontCopyThisField& from)
    {
        return *this;
    }

    DontCopyThisField& operator=(DontCopyThisField&& from)
    {
        T::operator=(static_cast<T&&>(from));
        return *this;
    }
};

c ++ copy constructor - 除了一个字段之外的所有字段的隐式副本？

3 个答案: