If a destructor called during stack unwinding exits with an exception, std::terminate is called

struct Some { int t; ~Some() { cout << t << " "; } };

struct X : Some
{
  Some member;
  bool e;
  X() : e(false) {}
  ~X() { if(e) throw 123; }
};

int main()
{
  try
  {
    X x[10]; // последовательно конструируются x[0], x[1], ..., x[9]
    for(int i=0; i!=10; ++i) { x[i].t = i*10; x[i].member.t = i*10 + 1; }
    x[5].e = true;
  }          // последовательно разрушаются x[9], x[8], ..., x[5], в т.ч. его члены и базы в рамках размотки.
             // остальные x[4]...x[0] проигнорированы
  catch(...) {}
}

template<int Size> struct array : array<Sise-1> { X & operator[] (int); };

NB>template<int Size> struct array : array<Sise-1> { X & operator[] (int); };
NB>

size_t n = size;
while(n!=0) call_destructor(data[--n]); // вылетело - так уж вылетело
free(data);

size_t n = size;
try
{
  while(n!=0) call_destructor(data[--n]);
}
catch(...)
{
  try
  {
    while(n!=0) call_destructor(data[--n]);
  }
  catch(...) { terminate(); }
  throw;
}
free(data);

struct do_destruct
{
  T*& data;
  size_t& n;
  do_destruct(T*& data, size_t& n) : data(data), n(n) {}
  ~do_destruct()
  {
    if(!data) return;
    while(n) data[--n].~T();
    free(data);
    data = 0;
  }
};

........

{
  do_destruct second_chance(data,n);
  do_destruct first_attempt(data,n);
}

Expression: X::value_type
Return type: T
Assertion/note pre-/post-condition: Requires: T is Destructible

Expression: u.~T()
Post-condition: All resources owned by u are reclaimed, no exception is propagated.

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:

[...]

— for types used as template arguments when instantiating a template component, if the operations on the type do not implement the semantics of the applicable Requirements subclause (17.6.3.5, 23.2, 24.2, 26.2). Operations on such types can report a failure by throwing an exception unless otherwise specified.

— if any replacement function or handler function or destructor operation exits via an exception, unless specifically allowed in the applicable Required behavior: paragraph.

    /**
      Usage - err(sOk) << "This is a description"
      */
    struct err : public std::stringstream
    {
        err(result_code_t::code_e code) : code_(code) {}
        ~err()
        {
            //Yes, we're throwing from a destructor
            if (code_!=result_code_t::sOk)
            {
                boost::throw_exception(my_exception(result_code_t(code_, str())));
            }
        }

    private:
        result_code_t::code_e code_;
    };

    /**
      Usage: some_function(...) | die;
      */     
    inline void operator | (const result_code_t &code, const die_t &)
    {
        if (!code.ok())
            boost::throw_exception(my_exception(code));
    }

C>    /**
C>      Usage - err(sOk) << "This is a description"
C>      */
C>    struct err : public std::stringstream
C>    {
C>        err(result_code_t::code_e code) : code_(code) {}
C>        ~err()
C>        {
C>            //Yes, we're throwing from a destructor
C>            if (code_!=result_code_t::sOk)
C>            {
C>                boost::throw_exception(my_exception(result_code_t(code_, str())));
C>            }
C>        }

C>    private:
C>        result_code_t::code_e code_;
C>    };

C>    /**
C>      Usage: some_function(...) | die;
C>      */     
C>    inline void operator | (const result_code_t &code, const die_t &)
C>    {
C>        if (!code.ok())
C>            boost::throw_exception(my_exception(code));
C>    }
C>

A declaration of a destructor that does not have an exception-specification is implicitly considered to have the same exception-specification as an implicit declaration (15.4).

An implicitly declared special member function (Clause 12) shall have an exception-specification. If f is an implicitly declared default constructor, copy constructor, move constructor, destructor, copy assignment operator, or move assignment operator, its implicit exception-specification specifies the type-id T if and only if T is allowed by the exception-specification of a function directly invoked by f’s implicit definition; f shall allow all exceptions if any function it directly invokes allows all exceptions, and f shall allow no exceptions if every function it directly invokes allows no exceptions.