重用复制和交换习语

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;

这只会打印两次“default”，既不打印“copy”也不打印“swap”。我在这里错过了什么？

Answer 1

这个：

 Derived& operator=(Derived copy)

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

记住 12.8：

用户声明的复制赋值运算符 X::operator= 是非静态的 类 X 的非模板成员函数，只有一个参数 类型 X、X&、const X&、volatile X& 或 const volatile 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<Derived> 赋值运算符，一次通过派生类生成的赋值运算符。要纠正这种情况，您必须这样做（并且不要忘记这样做）：

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

如果内存正常，您不能将赋值运算符作为特殊情况继承。我相信如果您需要，他们可以明确地using'd。

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

Answer 3

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

无论你做什么，你都处于两种情况中的任何一种：

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

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

Copy-And-Swap 仅用于非常特定的类。我觉得不值得。

Answer 4

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

    using copy_and_swap<Foo>::operator=;

你会看到一个错误告诉你关于 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. already did），但如果你反转继承，你可以让它工作：

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;
}