void function1()
{
   try
   {
       throw new IllegalStateException();
   } finally
   {
       System.out.println("1");
   }
}

void function2()
{
   try
   {
       function1();
   } finally
   {
       System.out.println("2");
   }
   System.out.println("3");
}


void function3()
{
   try
   {
       function2();
   } finally
   {
       System.out.println("4");
   }
   System.out.println("5");
}

myLock.lock();
try {
  //критический фрагмент кода
  ...............
}
finally{
  myLock.unlock();
}

Connection conn = getConnection();
try {
  //че-то делаем
  ....
}
finally {
  conn.close();
}

{
  std::ifstream file("data.txt");
  if ( !file ) {
    return false;//файл не открылся
  }
  //работаем с файлом
  .....
  //файл закроется автоматически, при уничтожении обьекта
}

r.open();
try {
  //критический код
  ...
}
catch(...){//либо перехватываем все исключения, либо базовое(std::exception), как надо так и делаем
  //поймано исключение
  ...
}
r.close();//кидаем исключения на право и на лево так, что б аж в глазах потемнело

    var file1 = new File(...);
    try
    {
        //
    }
    finally
    {
        try
        {
            file1.Dispose();
        }
        catch (Exception ex) { }
    }

try {
  //
} catch {
  // finally code
  throw;
}

{
  // finally code
}

The automatic protection of programs and/or processing systems when a hardware or software failure is detected in a computer system. See fail-safe (computer).

In engineering, Fault-tolerant design, also known as fail-safe design, is a design that enables a system to continue operation, possibly at a reduced level (also known as graceful degradation), rather than failing completely, when some part of the system fails.

The process of calling destructors for automatic objects constructed on the path from a try block to a
throw-expression is called “stack unwinding.”

class A {
  public: ...
    ~A() { if(some_condition) throw some_error(); }
  ...
};
class B {
  public: ...
    ~B() { cleanup_some_important_resource(); }
    ...
};

class C {
  private :
    A m_a;
    B m_b;
  ...
}

void C::__destroy_C_object() {
  // Сначала деструктор C.
  try { this->~C(); } catch( ... ) { ... }
  // Потом деструктор m_a.
  try { this->m_a.~A(); } catch( ... ) { ... }
  // Потом деструктор m_b.
  try { this->m_b.~B(); } catch( ... ) { ... }
}

D>И делается это одним движением, и без малейших напрягов. Для C++ же Вы вот уже пробовали написать аналогичный функционал. Как успехи с доточкой ???

D>    var file1 = new File(...);
D>    try
D>    {
D>        //
D>    }
D>    finally
D>    {
D>        try
D>        {
D>            file1.Dispose();
D>        }
D>        catch (Exception ex) { }
D>    }
D>

file f;
try
{
}
catch ( ... )
{
}
f.close();

try
{
  f1(); // throws
}
finally
{
  // Тут как понять, что летит исключение?
}

try
{
  f1(); // throws
}
catch // try throwed
{
  // cleanup without throw
  throw; // rethrow original exception
}
// try not throwed
// cleanup with throw

my::~my()
{
  // cleanup
  if (!std::uncaught_exception())
    throw ...;
}

file f; // destructor may throw (only if !std::uncaught_exception)
try
{
}
catch ( ... )
{
  f.close(); // throws new exception
}
// destructor throws new exception

void foo()
{
  // летит ли сейчас исклчюение? т.е. если я брошу - затру ли я его?
}