离开方法时重置变量值

时间:2018-07-10 08:04:58

标签: c++ c++11

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

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

    private:
        bool mLocked;
};

我希望在myFunc返回时将变量重置为先前的值。将mLocked设置为true和false似乎不可靠,以防万一有人在方法中间添加了返回值。

我已经通过创建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;
};

然后myFunc会这样做:

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

这一切都很好...但是我觉得我正在重新发明轮子。我很好奇是否有人知道标准库中是否已经存在这样的东西?我什么也找不到,但是我觉得它足够通用,我不应该自己写。

这是一个很小的代码块,如果我重新发明轮子,这并不可怕,但是我只是想减少不断扩展的代码库中的重复代码量,如果已经有不错的方法可以做到这一点

2 个答案:

答案 0 :(得分:1)

没有完全通用的示波器保护器。您可以将std::unique_ptr与自定义删除器一起使用。您必须自己决定这看起来是否太丑陋。也许可以使用一些using declarations使其变得更好。

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

打印:

0
1
0

但是如上所述,这似乎有点奇怪……您是否希望其他人会一直在观察该类成员(在这种情况下,您需要真正的同步)?否则,最好将此变量设置为局部变量,或者将其作为参数传递给您调用的函数。

答案 1 :(得分:1)

我会选择:

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...