class machines
{
 
...
private:
  std::list<std::tr1::shared_ptr<state> > states;
}

15.2(3)
The process of calling destructors for automatic objects constructed on the path from a try block to a throw-expression is called “stack unwinding.” [Note: If a destructor called during stack unwinding exits with an exception, terminate is called (15.5.1). So destructors should generally catch exceptions and not let them propagate out of the destructor. —end note]

B>>~machine()
B>>{
B>>for (list<state*>::iterator it=states.begin();it!=states.end();it++)
B>>    delete (*it);
B>>}

Object t; // деструктор генерирует исключение
//...
throw exception();
//...

ЮЖ>Object t; // деструктор генерирует исключение
ЮЖ>//...
ЮЖ>throw exception();
ЮЖ>//...
ЮЖ>

#include <boost/shared_ptr.hpp>

class A {};

void main()
{
  A* a = new A();
  boost::shared_ptr<A> p(a); //умный указатель, который не перехватывает исключения в свое деструкторе
  delete a; //наши кривые руки (упрощенная модель)
  throw std::exception(); //бросок исключения и в процессе раскрутки стека еще одно исключение, летящее из деструктора boost::shared_ptr
}

{
  scoped_ptr<DelayedFileWrite> file(new DelayedFileWrite(name)); // файл с отложенной записью
  ...
  // запись в деструкторе, при ошибке кидает, так надо знать, что ошибка произошла.
}

AG>{
AG>  scoped_ptr<DelayedFileWrite> file(new DelayedFileWrite(name)); // файл с отложенной записью
AG>  ...
AG>  // запись в деструкторе, при ошибке кидает, так надо знать, что ошибка произошла.
AG>}
AG>

{
  DelayedFileWrite file1(name1); 
  DelayedFileWrite file2(name2); 
  //...

  // А если я выну флешку, на которую оба эти файла должны были бы быть записаны ?

  // ...
}

std::for_each(states.begin(), states.end(), boost::checked_delete<state>);

1 In certain cases (replacement functions, handler functions, operations on types used to instantiate standard library template components), the C++ Standard Library depends on components supplied by a C++ program. If these components do not meet their requirements, the Standard places no requirements on the implementation.

2 In particular, the effects are undefined in the following cases:
[...]
— if any replacement function or handler function or destructor operation throws an exception, unless specifically allowed in the applicable Required behavior paragraph.

R>#include <boost/shared_ptr.hpp>

R>class A {};

R>void main()
R>{
R>  A* a = new A();
R>  boost::shared_ptr<A> p(a); //умный указатель, который не перехватывает исключения в свое деструкторе
R>  delete a; //наши кривые руки (упрощенная модель)
R>  throw std::exception(); //бросок исключения и в процессе раскрутки стека еще одно исключение, летящее из деструктора boost::shared_ptr
R>}
R>

struct X
{
  api::resource m_resource;

  void close()
  {
    int r = api::close(m_resource);
    if(r != OK)
      throw some_exception(r);
  }

  ~X()
  {
    api::close(m_resource); // nothrow
  }
};

struct X
{
  api::resource m_resource;

  void close() {
    api::close(m_resource);
  }

  ~X()
  {
    try {
      this->close();
    } catch(const std::exception&)
    {}
  }
};

struct X
{
  void close()
  {
    int r = api::close(m_resource);
    if(r != OK)
      throw some_exception(r);
  }

  ~X()
  {
     this->close();    
  }
}

X::~X() {
  m_thd.wait_for();
}

struct A    
{
    A(){}
    ~A()
    {
        if (std::uncaught_exception())
        {
            try
            {
               throw;
            }
            catch (exception& inner)
            {
                throw exception("Bla-bla-bla",inner);
            }                   
      
        }
        else        
        {
            throw exception("Bla-bla-bla");
        }
    }
};

void some_exception_handler()
{
    try
    {
        throw;
    }
    catch (LackOfDiskSpace &)
    {
        for (;;)
        {
            auto user_decision = show_dialog(....);

            if (user_decision == eliminate_error)
                break;
            if (user_decision == ignore_error)
                throw;
            if (user_decision == suspend_task)
            {
                switch_to_other_task();
                wait(); // suspend thread for some time
            }
        }
    }
}

class X
{
public:
    X(...., boost::function<void ()> const &exception_handler) :
        m_exception_handler(exception_handler),
        ....
    {
        ....
    }
    ~X()
    {
        for (;;)
            try
            {
                destruction(); // may throw
                break;
            }
            catch (...)
            {
                try
                {
                    m_exception_handler();
                }
                catch (...)
                {
                    break; // ignore error
                }
            }
    }
    ....
private:
    void destruction();
    boost::function<void ()> m_exception_handler;
    ....
};

void f()
{
    X x(...., some_exception_handler);
}

/*virtual*/ void X::set_error_handler(function<void()>)

НИ>Хотя веских причин для принятия такого решения я не знаю

void X::close()
{
  assert(!closed);
  if(!api::close(...))
    throw some_exception();
  assert(closed);
}

X::~X()
{
  if(!closed)
    api::close(...);
}

// обычная обработка исключений
try
{
    ....
}
catch (ExceptionType &)
{
    ....
}

// задаём последний обработчик (выполняемый на месте возникновения ошибки) как аргумент конструктора,
// деструктор удалит этот обработчик из списка локальных обработчиков потока
LocalExceptionHandler local_exception_handler(handler_function);

void X::close()
{
  assert(!closed);
  if(!api::close(...))
    throw some_exception();
  assert(closed);
}

X::~X()
{
  if(!closed)
    api::close(...);
}

enum ClosingPolicy { close_explicitly, close_soever };

....

X::X(ClosingPolicy closing_policy = close_explicitly) :
  m_closing_policy(closing_policy) {}

void X::close()
{
  if (closed)
    return;
  if (!api::close(....))
    throw some_exception();
  assert(closed);
}

X::~X()
{
  if (!closed)
  {
    assert(m_closing_policy != close_explicitly)
    api::close(....);
  }
}

void X::close()
{
  if (closed)
    return;
  if (!api::close(....))
    throw some_exception();
  assert(closed);
}

X::~X()
{
 if (!closed)
 {
    assert(m_closing_policy != close_explicitly)
    api::close(....);
  }
}

{
  X x;
  x.write("hello"); // бросает
  x.close(); // пропускаем
} // сработал assert. как фиксим?

{
  X x;
  x.write("hello"); // бросает
  x.close(); // пропускаем
} // сработал assert. как фиксим?

{
  X x;
  try
  {
    x.write("hello");
  }
  catch (...)
  {
    try
    {
      x.close();
    }
    catch (...)
    {
      .... // как-то обрабатываем или просто замалчиваем
    }
    throw;
  }
  x.close();
}