E>... раз две недели роняя ответственный сервер клиента в непонятный момент по терминэйт, без логов и сохранения данных. Прекрасное решение, демонстрирующее всю мощь RAII в кривых руках...

Precondition failures indicate coding errors, which are non-recoverable conditions. Exceptions are for recoverable conditions. No point in unwinding if you won’t be able to recover. In general, you should only throw in response to a precondition failure if you can’t convince your customer that further arbitrarily erroneous (aka undefined) behavior is worse than termination.

#include <boost/test/included/prg_exec_monitor.hpp> 
#include <boost/test/execution_monitor.hpp>
#include <exception>
#include <iostream>
#include <ostream>
 
using namespace std;
 
void myterminate ()
{
  cerr << "terminate handler called\n";
}
int terminator()
{
    terminate();
}
int cpp_main( int, char* [] )
{
    set_terminate(myterminate);
    boost::execution_monitor m;
    try
    {
        m.execute(terminator);
    }
    catch ( boost::execution_exception const& ex )
    {
        cout << "Caught exception: " << ex.what() << endl;
    }
    cout << "Alive!" << endl;
    return 0;
}

struct Foo
{
    UNWINDING_AWARE_DESTRUCTOR(Foo,due_to_unwinding)
    {
        if(due_to_unwinding)
            // ...
        else
            // ...
    }
};

A>Конечно в с++11 есть current_exception(), но проверять и отлавливать свои исключения...

18.8.5/8
current_exception Returns: An exception_ptr object that refers to the currently handled exception

EP>{
EP>    File a(/*...*/),b(/*...*/);
EP>    /* ... */
EP>    /* use a and b*/
EP>    b.flush();
EP>    a.flush();
EP>}
EP>

EP>{
EP>    File a(/*...*/),b(/*...*/);
EP>    /* ... */
EP>    /* use a and b*/
EP>}
EP>

{
    File a(/*...*/),b(/*...*/);
    scope(success)
    {
        b.flush();
        a.flush();
    }
    /* ... */
    /* use a and b*/
}

{
    SCOPE_FAILURE(void) {
        log("could not update user info");
    } SCOPE_FAILURE_END

    File passwd("/etc/passwd");

    SCOPE_SUCCESS( (&passwd) ) {
        passwd.flush();
    } SCOPE_SUCCESS_END

    BOOST_SCOPE_EXIT( (&passwd) ) {
        passwd.close();
    } BOOST_SCOPE_EXIT_END

    // ...
}

#include "stdafx.h"

#include <iostream.h>


struct TestObj {
   virtual ~TestObj() {}
   TestObj() { cout << "Start build obj at 0x" << hex << (int)this << endl; }   
};

struct ThrowInCtor : TestObj {
   ThrowInCtor() { throw 1; }
};

struct ObjOwner {
   ObjOwner( TestObj* p ) { cout << "Take obj: 0x" << hex << (int)p << endl; }
};

void foo( ObjOwner a1, ObjOwner a2 ) {}



int main(int argc, char* argv[])
{
   try {
      foo( new ThrowInCtor, new TestObj );
   } catch( int i ) {
      cout << i << " catched" << endl;
      return i;
   }

    
    return 0;
}

Start build obj at 0x220030
Start build obj at 0x2217d0
1 catched

   ThrowInCtor() { throw 1; }

Start build obj at 0x430030
Start build obj at 0x4317d0
Take obj: 0x430030
Take obj: 0x4317d0

for( int i = 0; i < bib_number; i++ ) {
    MyClass p( x+y+z+QQQ );
    p.Do( i );
}

EP>>{
EP>>    File a(/*...*/),b(/*...*/);
EP>>    /* ... */
EP>>    /* use a and b*/
EP>>    b.flush();
EP>>    a.flush();
EP>>}
EP>>

EP>>{
EP>>    File a(/*...*/),b(/*...*/);
EP>>    /* ... */
EP>>    /* use a and b*/
EP>>}
EP>>

{
KK>    File a(/*...*/),b(/*...*/);
KK>    scope(success)
KK>    {
KK>        b.flush();
KK>        a.flush();
KK>    }
KK>    /* ... */
KK>    /* use a and b*/
KK>}

{
    File a(/*...*/),b(/*...*/);
    SCOPE_SUCCESS(&a,&b)
    {
        b.flush();
        a.flush();
    } SCOPE_SUCCESS_END
    /* ... */
    /* use a and b*/
}