// RAII подход

class ResA // используется только в функции Func_RAII
{
  Handle m_Handle;

  this(...)
  {
    m_Handle = AllocResA(...);
  }

  ~this()
  {
    FreeResA(m_Handle);
  }
}

class ResB // используется только в функции Func_RAII
{
  Handle m_Handle;

  this(...)
  {
    m_Handle = AllocResB(...);
  }

  ~this()
  {
    FreeResB(m_Handle);
  }
}

class ResC // используется только в функции Func_RAII
{
  Handle m_Handle;

  this(...)
  {
    m_Handle = AllocResC(...);
  }

  ~this()
  {
    FreeResC(m_Handle);
  }
}

void Func_RAII(...)
{
  scope A = new ResA(...);
  scope B = new ResB(...);
  scope C = new ResC(...);
  // использовать ресурсы A, B, C
  ...
}

// scope(exit) подход

void Func_ScopeExit(...)
{
  Handle hResA = AllocResA(...);
  scope(exit) FreeResA(hResA);

  Handle hResB = AllocResB(...);
  scope(exit) FreeResB(hResB);

  Handle hResC = AllocResC(...);
  scope(exit) FreeResC(hResC);

  // использовать ресурсы A, B, C
  ...
}

The RAII solution often requires the creation of an extra dummy class, which is both a lot of lines of code to write and a lot of clutter obscuring the control flow logic. This is worthwhile to manage resources that must be cleaned up and that appear more than once in a program, but it is clutter when it only needs to be done once.
…
The RAII approach involves the creation of dummy classes, and the obtuseness of moving some of the logic out of the abc() function.

glPushMatrix();
try
{
  glTranslated(...);
  glRotated(...);
  ...
}
finally
{
  glPopMatrix();
}

ListBox.DisableRepaint(); // WM_SETREDRAW wParam = FALSE
try
{
  for (100 раз)
  {
    ListBox.AddItem(...);
  }
}
finally
{
  ListBox.EnableRepaint(); // WM_SETREDRAW wParam = TRUE
}

ПС>void Func_RAII(...)
ПС>{
ПС>  scope A = new ResA(...);
ПС>  scope B = new ResB(...);
ПС>  scope C = new ResC(...);
ПС>  // использовать ресурсы A, B, C
ПС>  ...
ПС>}
ПС>

ПС>// scope(exit) подход

ПС>void Func_ScopeExit(...)
ПС>{
ПС>  Handle hResA = AllocResA(...);
ПС>  scope(exit) FreeResA(hResA);

ПС>  Handle hResB = AllocResB(...);
ПС>  scope(exit) FreeResB(hResB);

ПС>  Handle hResC = AllocResC(...);
ПС>  scope(exit) FreeResC(hResC);

ПС>  // использовать ресурсы A, B, C
ПС>  ...
ПС>}
ПС>

ПС>glPushMatrix();
ПС>try
ПС>{
ПС>  glTranslated(...);
ПС>  glRotated(...);
ПС>  ...
ПС>}
ПС>finally
ПС>{
ПС>  glPopMatrix();
ПС>}
ПС>

ПС>ListBox.DisableRepaint(); // WM_SETREDRAW wParam = FALSE
ПС>try
ПС>{
ПС>  for (100 раз)
ПС>  {
ПС>    ListBox.AddItem(...);
ПС>  }
ПС>}
ПС>finally
ПС>{
ПС>  ListBox.EnableRepaint(); // WM_SETREDRAW wParam = TRUE
ПС>}
ПС>

void soSomethingWithGl()
  {
    void pushAndDo( lazy void block ) {
      glPushMatrix();
      try { block; }
      finaly { glPopMatrix(); }
    }

    pushAndDo( {
      glTranslated(...);
      glRotated(...);
    } );
  }

void Func_TryFinally(...)
{
  Handle hResA = AllocResA(...);
  try
  {
    int CountA = GetCountA(hResA);
    for (int IndexA = 0; IndexA < CountA; IndexA++)
    {
      Handle hResB = AllocResB(... hResA ... IndexA ...);
      try
      {
        int CountB = GetCountB(hResB);
        for (int IndexB = 0; IndexB < CountB; IndexB++)
        {
          Handle hResC = AllocResC(... hResB ... IndexB ...);
          try
          {
            // использовать ресурс C
            ...
          }
          finally
          {
            FreeResC(hResC);
          }
        }
      }
      finally
      {
        FreeResB(hResB);
      }
    }
  }
  finally
  {
    FreeResA(hResA);
  }
}

void Func_ScopeExit(...)
{
  Handle hResA = AllocResA(...);
  scope(exit) FreeResA(hResA);
  int CountA = GetCountA(hResA);
  for (int IndexA = 0; IndexA < CountA; IndexA++)
  {
    Handle hResB = AllocResB(... hResA ... IndexA ...);
    scope(exit) FreeResB(hResB);
    int CountB = GetCountB(hResB);
    for (int IndexB = 0; IndexB < CountB; IndexB++)
    {
      Handle hResC = AllocResC(... hResB ... IndexB ...);
      scope(exit) FreeResC(hResC);
      // использовать ресурс C
      ...
    }
  }
}

When to use RAII, try-catch-finally, and Scope
RAII is for managing resources, which is different from managing state or transactions. try-catch is still needed, as scope doesn't catch exceptions. It's try-finally that becomes redundant.

class wrapper {}
auto wrapper w = new wrapper();

{
    FILE* topSecret = fopen("cia.txt");
    ON_BLOCK_EXIT(std::fclose, topSecret);
    ... use topSecret ...
} // topSecret automagically closed

ON_BLOCK_EXIT says: "I want this action to be performed when the current block exists."

References:
1. Generic<Programming>: Change the Way You Write Exception-Safe Code Forever by Andrei Alexandrescu and Petru Marginean

CS>class wrapper {}
CS>auto wrapper w = new wrapper();
CS>

class wrapper {};
scope wrapper w = new wrapper();

class wrapper {};
auto scope w = new wrapper();

scope class SomeResourceHolder { ... };

// Так сделать не получится:
SomeResourceHolder lockResource() { ... }
auto resource = lockResource();

class SomeResourceHolder { ... };
typedef std::auto_ptr< SomeResourceHolder > ResourceHolderPtr;

// Так делать в C++ можно без проблем.
ResourceHolderPtr lockResource() { ... }
ResourceHolderPtr resource = lockResource();

class View
{
  int m_ItemsLockCount;

  void Paint(bool LockItems)
  {
    if (LockItems) m_ItemsLockCount++;
    scope(exit) if (LockItems) m_ItemsLockCount--;
    // использовать Items
    ...
  }
}

#include "ScopeGuard.h" // ftp://ftp.cuj.com/pub/2000/cujdec2000.zip > alexandr.zip

class View
{
  int m_ItemsLockCount;

  void ConditionallyUnlockItems(bool LockItems) // вызывается динамически
  {
    if (LockItems) m_ItemsLockCount--;
  }

  void Paint(bool LockItems)
  {
    if (LockItems) m_ItemsLockCount++;
    ON_BLOCK_EXIT_OBJ(*this, &View::ConditionallyUnlockItems, LockItems); // здесь ScopeGuard
    // использовать Items
    ...
  }
};

#include "ScopeGuard.h"

class View
{
  int m_ItemsLockCount;

  class ConditionallyUnlockItems // функтор
  {
    View* m_pView;
    bool m_LockItems;
  public:
    ConditionallyUnlockItems(View* pView, bool LockItems)
    {
      m_pView = pView;
      m_LockItems = LockItems;
    }
    void operator()() // вызывается статически
    {
      if (m_LockItems) m_pView->m_ItemsLockCount--;
    }
  };
  friend class ConditionallyUnlockItems; // разрешить функтору доступ к View::m_ItemsLockCount

  void Paint(bool LockItems)
  {
    if (LockItems) m_ItemsLockCount++;
    ON_BLOCK_EXIT(ConditionallyUnlockItems(this, LockItems)); // здесь ScopeGuard
    // использовать Items
    ...
  }
};

void Func2()
{
  Handle hResA = AllocResA(...);
  scope(exit) FreeResA(hResA);

  Handle hResB = AllocResB(...);
  scope(exit) FreeResB(hResB);

  Handle hResC = AllocResC(...);
  scope(exit) FreeResC(hResC);

  // использовать ресурсы A, B, C
  ...
}

#include "ScopeGuard.h"

void Func_ScopeGuard(...)
{
  Handle hResA = AllocResA(...);
  ON_BLOCK_EXIT(FreeResA, hResA); // здесь ScopeGuard

  Handle hResB = AllocResB(...);
  ON_BLOCK_EXIT(FreeResB, hResB); // здесь ScopeGuard

  Handle hResC = AllocResC(...);
  ON_BLOCK_EXIT(FreeResC, hResC); // здесь ScopeGuard

  // использовать ресурсы A, B, C
  ...
}

class View {
  int m_ItemsLockCount;

  class ItemsLockCountIncrementer {
    bool m_NeedLock;
    int & m_LockCount;
  public :
    ItemsLockCountIncrementer( bool NeedLock, int & LockCount )
      : m_NeedLock( NeedLock ), m_LockCount( LockCount )
      {
        if( m_NeedLock ) ++m_LockCount;
      }
    ~ItemsLockCountIncrementer()
      {
        if( m_NeedLock ) --m_LockCount;
      }
  };

  void Paint( bool LockItems )
    {
      ItemsLockCountIncrementer ItemsLocker( LockItems, m_ItemsLockCount );
      ...
    }
};

// Так задумывал автор:
void Paint( bool LockItems )
  {
    if( LockItems ) m_ItemsLockCount++;
    scope(exit) m_ItemsLockCount--;
    ...
  }

// А вот так затем сделал майнтайнер:
void Paint( bool LockItems )
  {
    if( LockItems ) m_ItemsLockCount++;
    checkItemsLockCount();
    scope(exit) m_ItemsLockCount--;
    ...
  }

Full closure support added.

A delegate can be set to a non-static nested function:

int delegate() dg;

void test()
{   int a = 7;
    int foo() { return a + 3; }

    dg = &foo;
    int i = dg();    // i is set to 10
}

The stack variables referenced by a nested function are still valid even after the function exits (this is different from D 1.0). This is called a closure. Returning addresses of stack variables, however, is not a closure and is an error.

int* bar()
{   int b;
    test();
    int i = dg();    // ok, test.a is in a closure and still exists
    return &b;        // error, bar.b not valid after bar() exits
}