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

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

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（或者在这种情况下，移动和交换）确保析构函数立即运行，我相信这是一种更好的语义。

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

Answer 2

应该没问题，但它几乎没有the recommended technique of pass-by-value好，在这种情况下，移动构造函数将用于这种情况。

Answer 3

我的想法是析构函数将在＆＃34;其他＆＃34;不久

然后你的想法有缺陷。您可以从任何非const访问的对象移动到。在此之后，对象可以无限期地继续生存。

将当前数据放在旧对象中技术上正确。但这不是一个好主意。使用堆栈变量更好：

Example& operator=(Example &&other)
{
    Example temp(std::move(other));  //other is now empty.
    std::swap(hExample, temp);       //our stuff is in `temp`, and will be destroyed
    return *thisl
}

或者更好（如果您不使用Visual Studio）将您的东西存储在支持正确移动的包装器中，并让编译器生成的移动构造函数为您完成工作。

在移动赋值运算符中使用std :: swap重用析构函数逻辑是否有意义？

3 个答案: