c++ - 通过在 move 赋值运算符中使用 std::swap 来重用析构函数逻辑是否有意义？

Question

考虑以下几点:

class Example : boost::noncopyable
{
    HANDLE hExample;
public:
    Example()
    {
        hExample = InitializeHandle();
    }
    ~Example()
    {
        if (hExample == INVALID_HANDLE_VALUE)
        {
            return;
        }
        FreeHandle(hExample);
    }
    Example(Example && other)
        : hExample(other.hExample)
    {
        other.hExample = INVALID_HANDLE_VALUE;
    }
    Example& operator=(Example &&other)
    {
        std::swap(hExample, other.hExample); //?
        return *this;
    }
};

我的想法是析构函数很快就会在“其他”上运行，因此我不必通过使用交换在 move 赋值运算符中再次实现我的析构函数逻辑。但我不确定这是一个合理的假设。这样“可以”吗？

Answer 1

想象一下:

// global variables
Example foo;

struct bar {
    void f() {
        x = std::move(foo); // the old x will now live forever
    }
    Example x;
}

一个类似的成语，copy-and-swap (或者在这种情况下， move 和交换)确保立即运行析构函数，我认为这是一个更好的语义。

Example& operator=(Example other) // other will be moved here
{
    std::swap(hExample, other.hExample);
    return *this;
} // and destroyed here, after swapping