RAII

From cppreference.com
< cpp‎ | language
 
 
C++ language
General topics
Flow control
Conditional execution statements
Iteration statements (loops)
Jump statements
Functions
Function declaration
Lambda function declaration
inline specifier
Exception specifications (deprecated)
noexcept specifier (C++11)
Exceptions
Namespaces
Types
Specifiers
decltype (C++11)
auto (C++11)
alignas (C++11)
Storage duration specifiers
Initialization
Expressions
Alternative representations
Literals
Boolean - Integer - Floating-point
Character - String - nullptr (C++11)
User-defined (C++11)
Utilities
Attributes (C++11)
Types
typedef declaration
Type alias declaration (C++11)
Casts
Implicit conversions - Explicit conversions
static_cast - dynamic_cast
const_cast - reinterpret_cast
Memory allocation
Classes
Class-specific function properties
Special member functions
Templates
Miscellaneous
 

"Resource Acquisition Is Initialization" or RAII, is a C++ programming technique[1] which binds the life cycle of a resource (memory allocation, socket, open file, mutex, database connection - anything that exists in limited supply) to the lifetime of an object with automatic storage duration, which guarantees that the resource is available to any function that may access the object and that all resources are cleaned up when the object goes out of scope, in reverse order of acquisition. This leverages the language to eliminate resource leaks and guarantee exception safety. Another name for this technique is "Scope-bound resource management" (SBRM).

RAII can be summarized as follows:

  • encapsulate each resource into a class, where
  • the constructor acquires the resource and establishes all class invariants or throws an exception if that cannot be done
  • the destructor always releases the resource
  • always use the resource via an instance of a RAII-class that either
  • has automatic storage duration
  • is a non-static member of a class whose instance has automatic storage duration

Classes with open()/close(), lock()/unlock(), or init()/copyFrom()/destroy() member functions are typical examples of non-RAII classes:

std::mutex m;
void bad() 
{
    m.lock(); // acquire the mutex
    f();      // if f() throws an exception, the mutex is never released
    if(!everything_ok()) return; // early return, the mutex is never released
    m.unlock(); // only if the code reaches this statement, the mutex is released
}
void good()
{
    std::lock_guard<std::mutex> lk(m); // RAII class: mutex acquisition is initialization
    f(); // if f() throws an exception, the mutex is released
    if(!everything_ok()) return; // early return, the mutex is released
} // if the function returns normally, the mutex is released

[edit] The standard library

The C++ library classes that manage their own resources follow RAII: std::string, std::vector, std::thread, and many others allocate their resources in constructors (which throw exceptions on errors), release them in their destructors, and don't require explicit cleanup.

In addition, the standard library offers several RAII wrappers to manage user-provided resources:

[edit] References

  1. RAII in Stroustrup's C++ FAQ