0

背景

假设您想在 C++ 中实现一个资源管理类。您不能使用零规则或五个默认规则，因此您实际上需要实现复制和移动构造函数、复制和移动赋值运算符和析构函数。在这个问题中，我将Box用作示例，但这可以适用于许多不同的类型。

// Store object on heap but keep value semantics
// Moved-from state has null elem; otherwise should have value
// Only valid operations on moved-from state are assignment and destruction
// Assignment only offers a basic exception guarantee
template <typename T>
class Box {
public:
    using value_type = T;

    // Default constructor
    Box() : elem{new value_type} {}
    // Accessor
    value_type& get() { return *elem; }
    value_type const& get() const { return *elem; }

    // Rule of Five
    Box(Box const& other) : elem{new value_type{*(other.elem)}} {};
    Box(Box&& other) : elem{other.elem}
    {
        other.elem = nullptr;
    };
    Box& operator=(Box const& other)
    {
        if (elem) {
            *elem = *(other.elem);
        } else {
            elem = new value_type{*(other.elem)};
        }
        return *this;
    }
    Box& operator=(Box&& other)
    {
        delete elem;
        elem = other.elem;
        other.elem = nullptr;
        return *this;
    }
    ~Box()
    {
        delete elem;
    }

    // Swap
    friend void swap(Box& lhs, Box& rhs)
    {
        using std::swap;
        swap(lhs.elem, rhs.elem);
    }
private:
    T* elem;
};

（请注意，更好的Box实现将具有更多的特性，例如noexcept和constexpr函数、explicit基于构造函数的转发构造value_type函数、分配器支持等；这里我正在实现问题和测试所必需的东西。它还可以使用 保存一些代码std::unique_ptr，但这会使它成为一个不太清楚的例子）

请注意，赋值运算符彼此共享大量代码，与它们各自的构造函数和析构函数共享。如果我不想让分配到从Boxen 移动，这会有所减轻，但在更复杂的类中会更明显。

题外话：复制和交换

处理此问题的一种标准方法是使用Copy-And-Swap Idiom（在此上下文中也称为“四半规则”）swap ，如果是，它还可以为您提供强有力的异常保证nothrow：

    // Copy and Swap (Rule of Four and a Half)
    Box& operator=(Box other)  // Take `other` by value
    {
        swap(*this, other);
        return *this;
    }

这允许您只编写一个赋值运算符（other如果可能，按值取值让编译器将另一个移动到参数，并在必要时为您进行复制），并且该赋值运算符很简单（假设您已经拥有swap）。但是，正如链接文章所说，这存在诸如在操作期间进行额外分配和保留内容的额外副本等问题。

理念

我以前没有见过的是我称之为销毁和初始化赋值运算符的东西。既然我们已经在构造函数中完成了所有工作，并且对象的分配版本应该与复制构造的对象相同，为什么不使用构造函数，如下所示：

    // Destroy-and-Initialize Assignment Operator
    template <typename Other>
    Box& operator=(Other&& other)
    requires (std::is_same_v<Box, std::remove_cvref_t<Other>>)
    {
        this->~Box();
        new (this) Box{std::forward<Other>(other)};
        return *std::launder(this);
    }

这仍然像 Copy-and-Swap 那样进行额外分配，但仅在复制分配情况下而不是在移动分配情况下，并且它在销毁 的一个副本后进行T，因此它不会在资源限制下失败。

问题

  1. 以前是否有人提出过这个建议，如果有，我可以在哪里阅读更多相关信息？
  2. 在某些情况下，这个 UB 是否Box是其他东西的子对象，或者它是否允许销毁和重建子对象？
  3. 这有什么我没有提到的缺点吗，比如不constexpr兼容？
  4. 当您不能只使用它们时，是否还有其他选项可以避免赋值运算符代码重用，例如这个和四点半规则= default？
4

0 回答 0