2

考虑以下：

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

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

4

3 回答 3

8

想象一下：

// 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-and-swap），确保析构函数立即运行，我认为这是一个更好的语义。

Example& operator=(Example other) // other will be moved here
{
    std::swap(hExample, other.hExample);
    return *this;
} // and destroyed here, after swapping
于 2012-03-17T02:37:16.210 回答
5

应该没问题，但它几乎不比推荐的按值传递技术好，在这种情况下，将在这种情况下使用移动构造函数。

于 2012-03-17T02:37:38.937 回答
3

我的想法是析构函数很快就会在“其他”上运行

那你的想法就有问题了。您可以从您具有非常量访问权限的任何对象中移动。在此之后，该对象可以无限期地继续存在。

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

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）将您的内容存储在正确支持移动的包装器中，并让编译器生成的移动构造函数为您完成这项工作。

于 2012-03-17T02:36:02.360 回答