可以安全地使用复制/移动ctors来实现复制/移动赋值操作符吗？

Question

我认为下面的代码比copy-and-swap idiom更好。

通过这种方式，你可以用两个宏来封装副本的定义和移动赋值运算符。换句话说，您可以避免在代码中明确定义它们。因此，您只能将注意力集中在ctors和dtor上。

是否有方法的任何不利？

class A 
{ 
public: 
    A() noexcept 
     : _buf(new char[128]) 
    {} 

    ~A() noexcept 
    { 
     if (_buf) 
     { 
      delete[] _buf; 
      _buf = nullptr; 
     } 
    } 

    A(const A& other) noexcept 
     : A() 
    { 
     for (int i = 0; i < 128; ++i) 
     { 
      _buf[i] = other._buf[i]; 
     } 
    } 

    A(A&& other) noexcept 
     : _buf(other._buf) 
    { 
     _buf = nullptr; 
    } 

    A& operator =(const A& other) noexcept 
    { 
     if (this != &other) 
     { 
      this->~A(); 
      new(this) A(other); 
     } 

     return *this; 
    } 

    A& operator =(A&& other) noexcept 
    { 
     if (this != &other) 
     { 
      this->~A(); 
      new(this) A(static_cast<A&&>(other)); 
     } 

     return *this; 
    } 

private: 
    char* _buf; 
}; 

Answer 1

class A 
{ 
public: 
    A() noexcept 
     : _buf(new char[128]) 
    {} 

在上文中，A()将调用std::terminate()如果new char[128]抛出异常。

~A() noexcept 
    { 
     if (_buf) 
     { 
      delete[] _buf; 
      _buf = nullptr; 
     } 
    } 

在上面，看起来没问题。可以简化到：

~A() noexcept 
    { 
     delete[] _buf; 
    } 



    A(const A& other) noexcept 
     : A() 
    { 
     for (int i = 0; i < 128; ++i) 
     { 
      _buf[i] = other._buf[i]; 
     } 
    } 

在上面，将调用std::terminate()如果new char[128]抛出异常。但否则罚款。

A(A&& other) noexcept 
     : _buf(other._buf) 
    { 
     _buf = nullptr; 
    } 

在上面，看起来不错。

A& operator =(const A& other) noexcept 
    { 
     if (this != &other) 
     { 
      this->~A(); 
      new(this) A(other); 
     } 

     return *this; 
    } 

在上面，通常我会说这是危险的。如果new(this) A(other);抛出？在这种情况下，它不会，因为如果它试图，程序将终止。这是否是安全行为取决于应用程序（终止并不适用于Ariane 5，但在更普通的应用程序中工作正常）。

A& operator =(A&& other) noexcept 
    { 
     if (this != &other) 
     { 
      this->~A(); 
      new(this) A(static_cast<A&&>(other)); 
     } 

     return *this; 
    } 

以上应该可以正常工作。虽然我不确定它是否优于下面的这个非分支版本以及其他相同的性能。行为差异在于以下版本不适用于自动分配。然而，我相信自动分配不必是无操作的，因为其中一个后置条件表明结果值没有指定（另一个后置条件表明它被指定，导致一个不可靠的矛盾）。

A& operator =(A&& other) noexcept 
    { 
     delete [] _buf; 
     _buf = nullptr; 
     _buf = other._buf; 
     other._buf = nullptr; 
     return *this; 
    } 

Answer 2

它会在您提供的上下文中正常工作。

这种技术将是灾难性的，当A是一个多态类和具有虚拟析构函数。

Answer 3

你可以大大使用unique_ptr<char[]>为_buf简化这一类：

class A 
{ 
public: 
    static const std::size_t bufsize = 128; 

    A() noexcept 
     : _buf(new char[bufsize]) 
    {} 

    A(const A& other) noexcept 
     : A() 
    { 
     copy_from(other); 
    } 

    A(A&& other) noexcept = default; 

    A& operator =(const A& other) noexcept 
    { 
     copy_from(other); 
     return *this; 
    } 

    A& operator =(A&& other) noexcept = default; 

private: 
    void copy_from(const A& other) noexcept { 
     std::copy_n(other._buf.get(), bufsize, _buf.get()); 
    } 

    std::unique_ptr<char[]> _buf; 
}; 

类是在未来变化的脸更短，更地道，更安全，因为它避免了“巧“delete +展示位置new。我个人会删除A()和A(const A&)的noexcept，但如果你想程序terminate上分配失败那是你的选择;）

如果你的目标仅仅是为了避免写赋值运算符 - 我不怪你，他们是烦人平庸 - 你应该设计到Rule of Zero：

class A 
{ 
public: 
    static const std::size_t bufsize = 128; 

    A() : _buf(bufsize) {} 

private: 
    std::vector<char> _buf; 
}; 

有 - 所有隐式拷贝和移动。