c++ - 如何抑制隐式复制构造函数/赋值运算符中的成员？

Question

我知道隐式复制构造函数/赋值运算符会按成员方式复制源对象。

假设我的类(class)有 1000 名成员。我想在进行赋值赋值时抑制其中一个成员(并且应用默认值)，其他 999 个成员仍然使用 member-wise copy 作为隐式赋值运算符。

例如:

class Foo
{
    std::string s1;
    std::string s2;
    std::string s3;
    ....
    std::string s1000;
};

然后我们用一些值填充对象 f1:

Foo f1;
f1.s1 = "a";
f1.s2 = "b";
f1.s3 = "c";
...

现在我们将 assign f1 (source) 复制到 f2 (target)

Foo f2 = f1;

如果要抑制“s2”，如何实现如下结果？

assert(f2.s1 == "a");
assert(f2.s2 == "");        //default value 
assert(f2.s3 == "c");

我知道提供复制构造函数/赋值运算符可以解决这个问题。

class Foo
{
    Foo( const Foo& other)
    {
        s1 = other.s1;
        //s2 = other.s2;    //suppress s2
        s3 = other.s3;
        ...
        s1000 = other.s1000;
    };

    Foo& Foo::operator=( const Foo& other)
    {
        s1 = other.s1;
        //s2 = other.s2;    //suppress s2
        s3 = other.s3;
        ...
        s1000 = other.s1000;

        return *this;
    };

    std::string s1;
    std::string s2;
    std::string s3;
    ....
    std::string s1000;
};

但是，我有 1000 个成员。我不想实现这么大的功能。

如果我实现这样的功能:

class Foo
{
    Foo( const Foo& other)
    {
        *this = other;
        s2 = "";
    };

    Foo& Foo::operator=( const Foo& other)
    {
        *this = other;
        s2 = "";
        return *this;
    };
}

显然，这是无限递归。

目前我唯一的选择是:

Foo f2 = f1;
f2.s2 = "";

但是，假设我的项目中有数千个Foo f2 = f1; 语句。找到它们并在它们之后追加一行太难了。

因此，我希望通过最少的代码更改来自定义对象的成员拷贝。我该怎么做？

Answer 1

我也同意 @gsamaras你必须记住单一责任原则。但与他们的回答不同，我认为你可以吃蛋糕也可以吃。

让我们检查一下您类(class)的职责。首先，它不关心所有数据成员是如何被复制的。该责任被委托(delegate)给每个成员所属的类型。我们应该坚持这一点，因为这种认识清楚地表明了谁应该负责。

有问题的数据成员 s2 是一个 std::string。该类型复制自身。但是如果我们包装它呢？

template<typename T>
class suppress_copies {
  T _mem;
public:
  // Allow changing the held member
  operator T&() { return _mem; }
  T& get()      { return _mem; }

  suppress_copies() = default;
  // But stop automatic copies (potentially even  handles moves)
  suppress_copies(suppress_copies const&) {} // default initialize the member
  suppress_copies& operator=(suppress_copies o) { // Accept default initialized "other" 
    using std::swap;
    swap(_mem, o._mem);
    return *this;
  }
};

差不多就是这样，这是负责抑制复制的类型。只需使用此包装器指定成员即可:

suppress_copies<std::string> s2;