重用复制和交换习惯用法

Question

我正在尝试将复制和交换习惯用法放入可重用的 mixin 中：

template<typename Derived>
struct copy_and_swap
{
    Derived& operator=(Derived copy)
    {
        Derived* derived = static_cast<Derived*>(this);
        derived->swap(copy);
        return *derived;
    }
};

我打算将其通过 CRTP 混合：

struct Foo : copy_and_swap<Foo>
{
    Foo()
    {
        std::cout << "default\n";
    }

    Foo(const Foo& other)
    {
        std::cout << "copy\n";
    }

    void swap(Foo& other)
    {
        std::cout << "swap\n";
    }
};

但是，一个简单的测试表明它不起作用：

Foo x;
Foo y;
x = y;

这只打印“默认”两次，也没有打印“打印“复制”或“交换”。我在这里缺少什么？

Answer 1

这：

 Derived& operator=(Derived copy)

没有为基类声明复制赋值运算符（它有错误的签名）。因此 Foo 中默认生成的赋值运算符不会使用该运算符。

记住12.8：

用户声明的复制赋值运算符 X::operator= 是非静态的
类 X 的非模板成员函数，只有一个参数为
类型 X、X&、const X&、易失性 X&或 const 易失性 X&。） [注：an
重载赋值运算符必须声明为只有一个
范围;见 13.5.3。 ] [注：副本分配的形式不只一种
可以为类声明运算符。 ] [注意：如果一个X类只有一个
带有 X& 类型参数的复制赋值运算符，其表达式为
类型 const X 不能分配给类型 X 的对象。

编辑 不要这样做（你能明白为什么吗？）：

你可以这样做：

template<typename Derived>
struct copy_and_swap
{
    void operator=(const copy_and_swap& copy)
    {
        Derived copy(static_cast<const Derived&>(copy));
        copy.swap(static_cast<Derived&>(*this));
    }
};

但是你失去潜在的复制省略优化。

事实上，这将分配两次派生类的成员：一次通过 copy_and_swap 赋值运算符，一次通过派生类生成的赋值运算符。要纠正这种情况，您必须执行以下操作（并且不要忘记）：

struct Foo : copy_and_swap<Foo>
{

    Foo& operator=(const Foo& x)
    {
        static_cast<copy_and_swap<Foo>&>(*this) = x;
        return *this;
    }

private:
    // Some stateful members here
}

这个故事的寓意：不要为复制和交换惯用法编写 CRTP 类嗯>。

Answer 2

如果内存正确的话，您不能将赋值运算符作为特殊情况继承。我相信如果您需要的话，可以显式使用它们。

另外，要小心过度使用复制和交换。它会产生非理想的结果，其中原始文件具有可以重复使用来制作副本的资源，例如容器。安全性得到保证，但最佳性能却没有得到保证。

Answer 3

恐怕这是需要宏的一个领域，因为自动生成的复制和赋值运算符的规则很复杂。

无论您做什么，您都会遇到以下两种情况之一：

• 您已经（显式）提供了赋值运算符的声明，在这种情况下，您也应该提供定义
• 您尚未（显式）提供赋值声明运算符，在这种情况下，如果基类和非静态成员有可用的，编译器将生成一个。

因此，下一个问题是：自动化这样的写入是否值得？

复制和交换仅用于非常特定的类。我认为这不值得。

Answer 4

编译器自动为 Foo 生成一个复制赋值运算符，因为没有。
如果将 a 添加

    using copy_and_swap<Foo>::operator=;

到 Foo，您将看到一个错误，告诉您 g++ 上的歧义。

Answer 5

也许您可以重写它，使其看起来像这样：

template<class Derived>
struct CopySwap
{
  Dervied &operator=(Derived const &other)
  {
    return AssignImpl(other);
  }

  Derived &operator=(Dervied &&other)
  {
    return AssignImpl(std::move(other));
  }

private:
  Derived &AssignImpl(Derived other)
  {
    auto self(static_cast<Derived*>(this));
    self->swap(other);
    return *self;
  }
};

它可能全部被内联，并且可能不会比原始代码慢。

Answer 6

这并没有真正回答问题（@Alexandre C. 已经这样做了)，但是如果你反转继承，你可以让它工作：

template<typename Base>
struct copy_and_swap : Base
{
    copy_and_swap& operator=(copy_and_swap copy)
    {
        swap(copy);
        return *this;
    }
};

struct Foo_
{
    Foo_()
    {
        std::cout << "default\n";
    }

    Foo_(const Foo_& other)
    {
        std::cout << "copy\n";
    }

    void swap(Foo_& other)
    {
        std::cout << "swap\n";
    }
};

typedef copy_and_swap<Foo_> Foo;

int main()
{
    Foo x;
    Foo y;
    x = y;
}