Krdytkyu

Often I'm in a situation where I need a simple RAII wrapper, but I wouldn't want to create a whole new class for this for many reasons including time constraints and organization problems. My quick-n-dirty solution is the following.

Say I want to make sure that by the end of the scope, I want a boolean to switch back to its original state:

bool prevState = currState;

currState      = newState;

std::unique_ptr<int, std::function<void(int*)>> txEnder(new int(0), [&prevState](int* p) {

    currState = prevState;

    delete p;

});

This solution works fine, but the dirty part is the necessity to allocate and deallocate that integer just to make unique_ptr work and call the custom destructor at destruction.

Is there a cleaner way to do this without having to write a whole class, and get rid of the new for the dummy int?

A little bit better than yours: You can use &prevState in the custom destructor without deleting it, so you do not need to new and delete something:

void foo(bool & currState, bool newState)

{

    bool prevState = currState;

    currState      = newState;

    std::unique_ptr<bool, std::function<void(bool*)>> txEnder(&prevState, [&prevState, &currState](bool* p) {

        currState = prevState;

    });

    cout << "currState: " << currState << endl;

}

You also forgot to capture currState in the lambda.

Here is an example: https://ideone.com/DH7vZu

You can use BOOST_SCOPE_EXIT

auto prevState{currState};

currState = newState;

BOOST_SCOPE_EXIT(&currState, &prevState)

{

     currState = prevState;

} BOOST_SCOPE_EXIT_END

Don't use std::function. It creates a lot of code including vtables. https://gcc.godbolt.org/z/XgDoHz

If you absolutely don't want to use any external class or function, do below:

bool foo_2() {

    bool f = false;

    auto eos = [&](void*){

        f = true;

    };

    std::unique_ptr<void, decltype(eos)> h{&eos,std::move(eos)};

    return f;

}

If you are ok with a little reusable function, below works. This abstracts the unused void*.

C++14 or later

template<class F>

auto call_at_end_of_scope(F&& f){

    auto eos = [f{std::forward<F>(f)}](void*){f();};

    return std::unique_ptr<void, decltype(eos)>{&eos,std::move(eos)};

}



bool foo_3() {

    bool f = false;

    auto handle = call_at_end_of_scope([&](){

        f = true;

    });

    return f;

}

How about gsl::finally? Library is not so heavy as boost and finally does not use std::function, so can be easly inlined. Also no dynamic allocation of std::unique_ptr

using namespace std;



void foo(bool & currState, bool newState)

{

    auto revertState = gsl::finally([prevState = currState, &currState]{

        currState = prevState;

    });

    currState = newState;       

    cout << "currState: " << currState << endl;

}





int main() {

    bool state = false;

    foo(state, true);

    cout << "state: " << state << endl;

    return 0;

}

Online example: https://ideone.com/Xi1izz (with copied gsl::finally, since #include <gsl/gsl> is not available here)