<p>Does C++ support '<a href="http://java.sun.com/docs/books/tutorial/essential/exceptions/finally.html" rel="noreferrer"><strong>finally</strong></a>' blocks?</p>

<p>What is the <a href="http://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization" rel="noreferrer"><strong>RAII idiom</strong></a>?</p>

<p>What is the difference between C++'s RAII idiom and <a href="http://www.c-sharpcorner.com/uploadfile/dipalchoksi/usingstatement11092005065819am/usingstatement.aspx" rel="noreferrer"><strong>C#'s 'using' statement</strong></a>?</p>

No, C++ does not support 'finally' blocks.  The reason is that C++ instead supports RAII: "Resource Acquisition Is Initialization" -- a
poor name
†
for a really useful concept.
The idea is that an object's destructor is responsible for freeing resources.  When the object has automatic storage duration, the object's destructor will be called when the block in which it was created exits -- even when that block is exited in the presence of an exception.  Here is
Bjarne Stroustrup's explanation
of the topic.
A common use for RAII is locking a mutex:
```
```
// A class with implements RAII
class lock
{
    mutex &m_;

public:
    lock(mutex &m)
      : m_(m)
    {
        m.acquire();
    }
    ~lock()
    {
        m_.release();
    }
};

// A class which uses 'mutex' and 'lock' objects
class foo
{
    mutex mutex_; // mutex for locking 'foo' object
public:
    void bar()
    {
        lock scopeLock(mutex_); // lock object.

        foobar(); // an operation which may throw an exception

        // scopeLock will be destructed even if an exception
        // occurs, which will release the mutex and allow
        // other functions to lock the object and run.
    }
};
```
```
RAII also simplifies using objects as members of other classes. When the owning class' is destructed, the resource managed by the RAII class gets released because the destructor for the RAII-managed class gets called as a result.  This means that when you use RAII for all members in a class that manage resources, you can get away with using a very simple, maybe even the default, destructor for the owner class since it doesn't need to manually manage its member resource lifetimes. (Thanks to
Mike B
for pointing this out.)
For those familliar with C# or VB.NET, you may recognize that RAII is similar to
.NET deterministic destruction using IDisposable and 'using' statements
.  Indeed, the two methods are very similar.  The main difference is that RAII will deterministically release any type of resource -- including memory.  When implementing IDisposable in .NET (even the .NET language C++/CLI), resources will be deterministically released except for memory.  In .NET, memory is not deterministically released; memory is only released during garbage collection cycles.
† Some people believe that "Destruction is Resource Relinquishment" is a more accurate name for the RAII idiom.