如何实现在范围退出时恢复价值的范围保护？

Question

以下是否是 Scope Guard 的惯用 C++11 实现，它在范围退出时恢复值？

template<typename T>
class ValueScopeGuard
{
public:
    template<typename U>
    ValueScopeGuard(T& value, U&& newValue):
        _valuePtr(&value),
        _oldValue(std::forward<U>(newValue))
    {
        using std::swap;
        swap(*_valuePtr, _oldValue);
    }
    ~ValueScopeGuard()
    {
        if(_valuePtr)
        {
            using std::swap;
            swap(*_valuePtr, _oldValue);
        }
    }

    // Copy
    ValueScopeGuard(ValueScopeGuard const& other) = delete;
    ValueScopeGuard& operator=(ValueScopeGuard const& other) = delete;

    // Move
    ValueScopeGuard(ValueScopeGuard&& other):
        _valuePtr(nullptr)
    {
        swap(*this, other);
    }
    ValueScopeGuard& operator=(ValueScopeGuard&& other)
    {
        ValueScopeGuard(std::move(other)).swap(*this);
        return *this;
    }

private:
    T* _valuePtr;
    T _oldValue;

    friend void swap(ValueScopeGuard& lhs, ValueScopeGuard& rhs)
    {
        using std::swap;
        swap(lhs._valuePtr, rhs._valuePtr);
        swap(lhs._oldValue, rhs._oldValue);
    }
};

template<typename T, typename U>
ValueScopeGuard<T> makeValueScopeGuard(T& value, U&& newValue)
{
    return {value, std::forward<U>(newValue)};
}

它可以用来临时改变一个值，如下所示：

int main(int argc, char* argv[])
{
    // Value Type
    int i = 0;
    {
        auto guard = makeValueScopeGuard(i, 1);
        std::cout << i << std::endl; // 1
    }
    std::cout << i << std::endl; // 0

    // Movable Type
    std::unique_ptr<int> a{new int(0)};
    {
        auto guard = makeValueScopeGuard(a, std::unique_ptr<int>{new int(1)});
        std::cout << *a << std::endl; // 1
    }
    std::cout << *a << std::endl; // 0

    return 0;
}

这样的简单实用程序是否已经在某个库中实现了？我查看了 Boost.ScopeExit，但它的预期用途似乎不同且更复杂。

Answer 1

假设makeValueScopeGuard 实现为：

template< typename T >
ValueScopeGuard<T> makeValueScopeGuard( T& t, T&& v )
{
    return ValueScopeGuard<T>(t,std::move(v));
}

不，范围保护的实现不是很好，因为当您将左值作为第二个参数传递时它会失败：

int kk=1;
auto guard = makeValueScopeGuard(i, kk);

第二个问题是你使用了std::forward，而你应该使用std::move。

---

正如this question and answers 所示，人们通常使用 lambdas 来实现范围保护。

Answer 2

您的移动构造函数使指针成员未初始化，因此右值对象最终持有一个垃圾指针，它在其析构函数中取消引用。那是一个错误。您应该将其初始化为 nullptr 并在析构函数中检查 nullptr。

对于这样的类型，我不希望移动分配是一个简单的交换，我希望右值最终不会拥有任何东西。所以我会像这样实现这个动作，所以右值最终是空的：

ValueScopeGuard& operator=(ValueScopeGuard&& other)
{
    ValueScopeGuard(std::move(other)).swap(*this);
    return *this;
}

makeValueScopeGuard 这个名字我不清楚它会改变值本身，我希望它只是复制当前值并在析构函数中恢复它。

就现有类型而言，我能想到的最接近的是Boost I/O state savers，它不会改变当前状态，它们只是复制并恢复它。