Does C Have a 'finally' Block Equivalent, and How Does RAII Achieve Similar Functionality?

Does C Support 'finally' Blocks and What is the RAII Idiom?

Unlike other languages, C does not explicitly support 'finally' blocks. Instead, it adopts the RAII (Resource Acquisition Is Initialization) idiom.

The RAII Idiom

RAII is a technique where an object's destructor becomes responsible for releasing any resources it acquires. This ensures that the resources are properly freed upon object destruction, regardless of the exit path (including exceptions).

Here's an example of using RAII to lock a mutex:

class lock {
public:
    lock(std::mutex& m) : m_(m) { m.lock(); }
    ~lock() { m_.unlock(); }
    std::mutex& m_;
};

void foo() {
    lock scopeLock(mutex_);
    // Some operation that may throw an exception
}

In this example, the destructor for the 'lock' object will release the mutex, even in the event of an exception.

RAII vs. C#'s 'using' Statement

Both RAII and C#'s 'using' statement are designed to ensure deterministic resource release. The key difference between the two is that RAII can be used for any resource type, including memory, while the .NET 'using' statement is primarily intended for releasing non-memory resources.

The above is the detailed content of Does C Have a 'finally' Block Equivalent, and How Does RAII Achieve Similar Functionality?. For more information, please follow other related articles on the PHP Chinese website!