void TheFunction()
{
    try {
        //твоя функция
    } catch(...) {
        ExceptionFilter();
    }
}

void ExceptionFilter()
{
    try {
        throw;
    } catch(Exception1 const& e) {
        //делаем одно
    } catch(Exception2 const& e) {
        //делаем второе
    } catch(Exception3 const& e) {
        //делаем третье
    } catch(Exception4 const& e) {
        //делаем четвертое
    } catch(Exception5 const& e) {
        //делаем пятое
    } catch(...) {
        //делаем еще что-то
    }
}

К>Офигеть.

15.1/7: The exception thrown is the one most recently caught and not finished. An exception is considered caught when initialization is complete for the formal parameter of the corresponding catch clause, or when terminate() or unexpected() is entered due to a throw. An exception is considered finished when the corresponding catch clause exits or when unexpected() exits after being entered due to a throw.

15.1/8: If no exception is presently being handled, executing a throw-expression with no operand calls terminate() (15.5.1).

КД>>Угу, но это уже очень не мало. Я когда сократил число катчей с 4 до 2 (перехват excеption и использование dymanic_cast) двух-мегабайтный COM-модуль похудел на 100K. Теперь я знаю как еще 100K выгадать

КД>>Кроме того за счет такой фичи можно ... короче, можно писать по-настоящему интересные приложения на плюсах. От которых программеров на других языках вывернет буквально наизнанку

HRESULT OLE_ProcessErrorException(REFCLSID              ComponentID,
                                  REFIID                InterfaceID,
                                  const std::exception* pExc,
                                  bool                  TranslateAllException)
{
 HRESULT hr=E_FAIL;

 try
 {
  if(g_OLE_ErrorExceptionHandler!=NULL)
  {
   //call user handler of exceptions
   hr=g_OLE_ErrorExceptionHandler(ComponentID,InterfaceID,pExc,TranslateAllException);
  }
  else
  if(pExc==NULL)
  {
   //unknown exception
   hr=E_UNEXPECTED;
  }
  else
  if(const t_base_com_error* const x=dynamic_cast<const t_base_com_error*>(pExc))
  {
   //create std object of automation error
   hr=x->create_error_info(InterfaceID);
  }
  else
  if(dynamic_cast<const bad_alloc*>(pExc)!=NULL)
  {
   hr=E_OUTOFMEMORY;
  }
  else
  {
   const char* const what=pExc->what();

   hr=E_FAIL;

   if(what!=NULL && (*what)!=0)
    ole_lib::CreateErrorInfo(InterfaceID,what,hr);
  }//else
 }
 catch(...)
 {
  hr=E_FAIL;
 }

 return hr;
}//OLE_ProcessErrorException

catch(const exception& e)
{
 throw;
}

КД>> catch(...)
КД>> {
КД>>  hr=E_FAIL;
КД>> }
КД>>}//OLE_ProcessErrorException

int main()
{
    try
    {
        throw 0;
    }
    catch(...)
    {
        try
        {
            throw 0;
        }
        catch(...)
        {
            printf("hello!\n");
        }
    }
}

DEA>void ExceptionFilter()
DEA>{
DEA>    try {
DEA>        throw;
DEA>    } catch(Exception1 const& e) {
DEA>        //делаем одно
DEA>    } catch(Exception2 const& e) {
DEA>        //делаем второе
DEA>    } catch(Exception3 const& e) {
DEA>        //делаем третье
DEA>    } catch(Exception4 const& e) {
DEA>        //делаем четвертое
DEA>    } catch(Exception5 const& e) {
DEA>        //делаем пятое
DEA>    } catch(...) {
DEA>        //делаем еще что-то
DEA>    }
DEA>}
DEA>

void g() throw(Yerr);

class STC{ // store and reset class
    unexpected_handler old;
public:
    STC(unexpected_handler f) { old = set_unexpected(f) ; }
    ~STC() { set_unexpected(old) ; }
};

class Yunexpected : public Yerr {};

void throwY() throw(Yunexpected) { throw Yunexpected(); }

void networked_g() throw(Yerr)
{
    STC xx( &throwY ); // Теперь unexpected() генерирует Yunexpected.
    g();
}

class Yunexpected : public Yerr {
public :
    Network_exception * pe;
    Yunexpected(Network_exception * p) : pe( p ? p->clone() : 0 ) {}
    ~Yunexpected() { delete pe; }
}

void throwY() throw(Yunexpected)
{
    try {
        throw; // Сгенерировать заново, чтобы немедлено перехватить!
    }
    catch( Network_exception & p ) {
        throw Yunexpected(&p); // Сгенерировать отображенное исключение.
    }
    catch( ... ) {
        throw Yunexpected(0);
    }
}

void exceptionHandler()
{
    ExceptionManager::getHandler().run();
}

void _exceptionHandler(const std::string& sFunctionName)
{
    LOG << "Exception: " << sFunctionName;
    // Реальная обработка исключения
}


#define exceptionHandler() _exceptionHandler(__FUNCTION__)

struct A1 {};
struct B1 : A1 {};
struct C1 : A1 {};
struct A2 {};
struct B2 : A2 {};
struct C2 : B2 {};

void exceptionHandler()
{
    try
    {
        throw;
    }
    catch (const A1&)
    {
        try
        {
            throw;
        }
        catch (const B1&)
        {
            handlingForB1();
        }
        catch (const C1&)
        {
            handlingForC1();
        }
        handlingForA1();
    }
    catch (const A2&)
    {
        try
        {
            throw;
        }
        catch (const B2&)
        {
            try
            {
                throw;
            }
            catch (const C2&)
            {
                handlingForC2();
            }
            handlingForB2();
        }
        handlingForA2();
    }
    handlingForAllErrors();
};

DEA>void TheFunction()
DEA>{
DEA>    try {
DEA>        //твоя функция
DEA>    } catch(...) {
DEA>        ExceptionFilter();
DEA>    }
DEA>}

DEA>void ExceptionFilter()
DEA>{
DEA>    try {
DEA>        throw;
DEA>    } catch(Exception1 const& e) {
DEA>        //делаем одно
DEA>    } catch(Exception2 const& e) {
DEA>        //делаем второе
DEA>    } catch(Exception3 const& e) {
DEA>        //делаем третье
DEA>    } catch(Exception4 const& e) {
DEA>        //делаем четвертое
DEA>    } catch(Exception5 const& e) {
DEA>        //делаем пятое
DEA>    } catch(...) {
DEA>        //делаем еще что-то
DEA>    }
DEA>}
DEA>

void TheFunction()
{
    try 
    {
        // предположим у нас тут зовется что-то вроде
        ....
        throw Exception1();
    }
    catch(...) 
    {
        ExceptionFilter();
    }                             // ВОТ ТУТ ВЫЗОВЕТСЯ ДЕСТРУКТОР ВТОРОЙ РАЗ

}

void ExceptionFilter()
{
    try 
    {
        throw;
    } 
    catch(Exception1 const& e) 
    {
        //делаем одно
    }                             // ВОТ ТУТ ВЫЗОВЕТСЯ ДЕСТРУКТОР ПЕРВЫЙ РАЗ
    catch(Exception2 const& e) 
    {
        //делаем второе
    } 
    catch(Exception3 const& e) 
    {
        //делаем третье
    } 
    catch(Exception4 const& e) 
    {
        //делаем четвертое
    } 
    catch(Exception5 const& e) 
    {
        //делаем пятое
    } 
    catch(...) 
    {
        //делаем еще что-то
    }
}

C>>Сколько душе угодно

AJD>Верю . Но хотелось бы цитату из стандарта.

15.1
6) A throw-expression with no operand rethrows the exception being handled. The exception is reactivated
with the existing temporary; no new temporary exception object is created. The exception is no longer considered
to be caught; therefore, the value of uncaught_exception() will again be true.

AJD>Верю . Но хотелось бы цитату из стандарта.

A throw-expression with no operand rethrows the exception being handled.
...
The exception is no longer considered to be caught;
...

...
An exception is considered caught when initialization is complete for the formal parameter of the corresponding catch clause
...
An exception is considered finished when the corresponding catch clause exits
...

If no exception is presently being handled, executing a throw-expression with no operand calls terminate()

An exception is considered handled upon entry to a handler.

#include <iostream>

//---------------------------------------
void ExceptionFilter () {
    try {
        throw;
    }
    catch (...) {
        std::cout << "in ExceptionFilter ..." << std::endl;
    }
}

//---------------------------------------
bool c () {
    ExceptionFilter (); // формально никто нам не запрещает написать (случайно при copy/paste) так где-то глубоко в коде.
    return true;
}

//---------------------------------------
bool b () {
    return c();
}

//---------------------------------------
bool a () {
    return b();
}

//---------------------------------------
int main () {
    try {

        a (); 
        
    }
    catch (...) {
        ExceptionFilter();
        std::cout << "in main ... " << std::endl;
    }
    return 0;
}

void ExceptionFilter () {
    try {
        throw;
    }
    catch (...) {
        std::cout << "in ExceptionFilter ..." << std::endl;
    }
}

int main( void )
{
  ExceptionFilter(); // формально никто нам не запрещает написать (случайно при copy/paste) так где-то глубоко в коде.
}