raii

I have some code which need to be thread safe and exception safe. The code below is a very simplified version of my problem : #include <mutex> #include <thread> std::mutex mutex; int n=0; class Counter{ public: Counter(){ std::lock_guard<std::mutex>guard(mutex); n++;} ~Counter(){ std::lock_guard<std::mutex>guard(mutex);//How can I protect here the underlying code to mutex.lock() ? n--;} }; void doSomething(){ Counter counter; //Here I could do something meaningful } int numberOfThreadInDoSomething(){ std::lock_guard<std::mutex>guard(mutex); return n;} I have a mutex that I need to lock in the

Objective-C can be mixed with c++ to some extent and can be called to each other . But Objective-C objects still are more or less manually managed, and RAII idiom is entirely absent from the language. I wonder if it is possible to manage the lifetimes of Objective-C objects with c++ smart pointers. Specially now that both boost scoped_ptr and shared_ptr have been added to the C++11 standard But Objective-C objects still are more or less manually managed, and RAII idiom is entirely absent from the language. I think this would seem to answer your question anyhow. Because Objective-C objects are

I cannot use boost or the latest std::thread library. The way to go is to create a custom implementation of a scoped mutex. In a few words when a class instance is create a mutex locks. Upon class destruction the mutex is unlocked. Any implementation available? I don't want to re-invent the wheel. I need to use pthreads. resource acquisition is initialization == “RAII” Note This is an old answer. C++11 contains better helpers that are more platform independent: std::lock_guard std::mutex , std::timed_mutex , std::recursive_mutex , std::recursive_timed_mutex And other options like std::unique

I hear talks of C++14 introducing a garbage collector in the C++ standard library itself. What is the rationale behind this feature? Isn't this the reason that RAII exists in C++? How will the presence of standard library garbage collector affect the RAII semantic? How does it matter to me(the programmer) or the way in which I write C++ programs? Ali Garbage collection and RAII are useful in different contexts. The presence of GC should not affect your use of RAII. Since RAII is well-known, I give two examples where GC is handy. Garbage collection would be a great help in implementing lock

The more we use RAII in C++, the more we find ourselves with destructors that do non-trivial deallocation. Now, deallocation (finalization, however you want to call it) can fail, in which case exceptions are really the only way to let anybody upstairs know of our deallocation problem. But then again, throwing-destructors are a bad idea because of the possibility of exceptions being thrown during stack unwinding. std::uncaught_exception() lets you know when that happens, but not much more, so aside from letting you log a message before termination there's not much you can do, unless you're

What is the most elegant solution for calling a function automatically when leaving a scope? My current approach (see below) works but I guess there should be something more general as writing a custom class for this. #include <iostream> #include <functional> using namespace std; class DoInDtor { public: typedef function<void()> F; DoInDtor(F f) : f_(f) {}; ~DoInDtor() { f_(); } private: F f_; }; void foo() { DoInDtor byeSayerCustom([](){ cout << "bye\n"; }); auto cond = true; // could of course also be false if ( cond ) return; return; } int main() { foo(); } Sure, one could abuse std::unique

C++ classes provide RAII idiom. Therefore you don't have to care about exceptions: void function() { // The memory will be freed automatically on function exit std::vector<int> vector(1000); // Do some work } But if you have (for some reasons) to use some pure C API, you have either to create C++ wrappers around it or to use try/catch blocks void function() { int *arr = (int*)malloc(1000*sizeof(int)); if (!arr) { throw "cannot malloc"; } try { // Do some work } catch (...) { free(arr); // Free memory in case of exception throw; // Rethrow the exception } // Free memory in case of success free

Is there any template available in boost for RAII . There are classes like scoped_ptr , shared_ptr which basically work on pointer. Can those classes be used for any other resources other than pointers. Is there any template which works with a general resources. Take for example some resource which is acquired in the beginning of a scope and has to be somehow released at the end of scope. Both acquire and release take some steps. We could write a template which takes two(or maybe one object) functors which do this task. I havent thought it through how this can be achieved, i was just wondering

This question already has an answer here: How to avoid C++ anonymous objects 6 answers For many RAII "guard" classes, being instantiated as anonymous variables does not make sense at all: { std::lock_guard<std::mutex>{some_mutex}; // Does not protect the scope! // The unnamed instance is immediately destroyed. } { scope_guard{[]{ cleanup(); }}; // `cleanup()` is executed immediately! // The unnamed instance is immediately destroyed. } From this article : Anonymous variables in C++ have “expression scope”, meaning they are destroyed at the end of the expression in which they are created. Is