C++ 离开方法时重置变量值

我有一个非性能关键的方法，我需要在方法的生命周期中设置一些类成员变量的值。例如：

class myClass
{
    public:
        void myFunc()
        {
            mLocked = true;
            // Do something...
            mLocked = false;
        }

    private:
        bool mLocked;
};

我希望在myFunc返回时将变量重置为上一个值。设置为真和假的锁看起来是不可靠的，只要有人在方法中间添加一个返回。< /P> 我通过创建一个RAII模板类来解决这个问题，该类在构造函数中设置值，并在析构函数中进行清理

    template<typename T>
class ScopedSetValue
{
    public:
        ScopedSetValue(
            T *pointer,
            T constructorValue,
            T destructorValue)
        {
            mPointer = pointer;
            mDestructorValue = destructorValue;
            if(nullptr != mPointer)
                *mPointer = constructorValue;
        }

        ScopedSetValue(
            T *pointer,
            T destructorValue)
        {
            mPointer = pointer;
            mDestructorValue = destructorValue;
        }

        ~ScopedSetValue()
        {
            if(nullptr != mPointer)
                *mPointer = mDestructorValue;
        }

    private:
        T *mPointer;
        T mDestructorValue;
};

模板
类ScopedSetValue
{
公众：
ScopedSetValue(
T*指针，
T构造函数值，
T析构函数值）
{
mPointer=指针；
MDEsstructorValue=析构函数值；
if（nullptr！=mPointer）
*mPointer=构造函数值；
}
ScopedSetValue(
T*指针，
T析构函数值）
{
mPointer=指针；
MDEsstructorValue=析构函数值；
}
~ScopedSetValue（）
{
if（nullptr！=mPointer）
*mPointer=MDEsstructorValue；
}
私人：
T*mPointer；
T mDestructor值；
};

那么myFunc只做：

void myFunc()
{
    ScopedSetValue<bool> scoped(&mLocked, true, false);
    return; // Set mLocked back to false
}

void myFunc（）
{
ScopedSetValue作用域（&mLocked，true，false）；
return；//将mLocked设置回false
}

这一切都很好。。。但我觉得我在重新发明轮子。我很好奇是否有人知道这样的东西是否已经存在于标准库中？我找不到任何东西，但我觉得它很普通，我不应该自己写这篇文章

---

这是一个足够小的代码块，如果我重新发明轮子，这并不可怕，但我只是试图在不断扩展的代码库中减少重复代码的数量，如果已经有一些很好的方法可以做到这一点的话。

没有完全通用的范围保护。可以将与自定义删除器一起使用。如果那看起来太难看，你必须自己决定；也许有一些你可以让它变得更好

#include <iostream>
#include <memory>
int main()
{
    bool flag = false;
    std::cout << flag << '\n';
    {
        std::unique_ptr<bool, std::function<void(bool*)>> resetter(
                &(flag=true),
                [](bool* flag){ *flag = false; });
        std::cout << flag << '\n';
    }
    std::cout << flag << '\n';
}

---

但如上所述，这似乎有点奇怪。。。您是否希望其他人全程观察该类成员（在这种情况下，您需要真正的同步）？否则，您最好将此变量设置为本地变量，或将其作为参数传递到您调用的函数中。

我会选择：

template <typename F>
class Finally {
    F f;
public:
    template <typename Func>
    Finally(Func&& func) : f(std::forward<Func>(func)) {}
    ~Finally() { /* try */ f();  /* catch(...) {} */ }

    Finally(const Finally&) = delete;
    Finally(Finally&&) = delete;
    Finally& operator =(const Finally&) = delete;
    Finally& operator =(Finally&&) = delete;
};

template <typename F>
Finally<F> make_finally(F&& f)
{
    return { std::forward<F>(f) };
}

---

旁注：如果你接受一个引用，你可以摆脱空检查。和有什么问题吗？这似乎是一个相当特殊的小生境——一个非原子的、非同步的变量，在特定函数运行时必须有一个特定的值。那么，谁来观察改变后的价值观呢？考虑到这种特殊性，很明显为什么不会有标准的图书馆支持依赖于这种糟糕做法的臭味。如果代码需要lock值，它应该被注入到代码中，而不仅仅是保持在可以更改的状态。你不是在重新发明轮子。你在重新发明棍子。它非常琐碎，您可能在任何库中都找不到它，并且可能不值得为它获取任何库。

template <typename F>
class Finally {
    F f;
public:
    template <typename Func>
    Finally(Func&& func) : f(std::forward<Func>(func)) {}
    ~Finally() { /* try */ f();  /* catch(...) {} */ }

    Finally(const Finally&) = delete;
    Finally(Finally&&) = delete;
    Finally& operator =(const Finally&) = delete;
    Finally& operator =(Finally&&) = delete;
};

template <typename F>
Finally<F> make_finally(F&& f)
{
    return { std::forward<F>(f) };
}

mLocked = true;
auto finally = make_finally([this](){ mLocked = false; });
// Do something...