catch(const std::exception& e)
{
 if(!<некоторое условие>)
  throw;

 //....
}

__try
{
    RaiseException(0xE3000001, 0, 0, NULL);
}
__except ((GetExceptionCode() == 0xE3000001 && <некоторое условие>) 
             ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
{

}

try
{
    // сильно много исключений вылетает отсюда
}
catch(...)
{
    if (!<некоторое условие>)
        throw;

    // ок, посмотрим что же там произошло и решим что делать...
    try
    {
        throw;
    }
    catch (const database::exception& e)
    {
        // 
    }
    catch (const http::exception& e)
    {
        // 
    }
    catch (const std::runtime_exception& e)
    {
        // 
    }
    catch (const std::exception& e)
    {
        // 
    }
}

catch (const std::exeception& e) if (some_condition)
{
}

КД>catch(const std::exception& e)
КД>{
КД> if(!<некоторое условие>)
КД>  throw;

КД> //....
КД>}
КД>

try {
  ...
} catch(...) { 
  context.analyze_exception(); 
}
...
void Context::analyze_exception() {
  try { throw; } 
  catch(const std::exception &e) {
    // complex logic here
    ...
  }
  catch(SomethingElse &se) {
  }
  ...
}

try { // какой-то внешний блок
  try { foo(); }
  catch(A a) { if(!test_a()) throw; accept_a(); } // по else прыгнем сразу на catch(D) и далее
  catch(B b) { if(!test_b()) throw; accept_b(); } // по else прыгнем сразу на catch(D) и далее
  catch(...) { accept_c(); }
}
catch(D d) { accept_d(); }
catch(...) { accept_e(); }

try { foo(); }
catch_if(A a, test_a()) { ... }
catch_if(B b, test_b()) { ... }
catch(...) { accept_c(); }

// почти эквивалентно
try {
  try {
    try { foo(); }
    catch(A a) { if(!test_a()) throw; accept_a(); }
  } catch(B b) { if(!test_b()) throw; accept_b(); }
}   catch(...) { accept_c(); }

template<class FUN, class... FUNS> void flat_catch(FUN&& f1, FUNS&&... fs) {
  try { f1(); }
  catch(...) { flat_catch(std::forward<FUNS>(fs)...); }
}
void flat_catch() { throw; }

int main() {
  try { foo(); }
  catch(...) { flat_catch(
      [&]() { throw; }
    , [&]() { try{ throw; } catch(A a) { if(!test_a()) throw; accept_a(); }
    , [&]() { try{ throw; } catch(B b) { if(!test_b()) throw; accept_b(); }
    , [&]() { try{ throw; } catch(...) {                      accept_c(); }
  }

#define TRY try {
#define BEGIN_CATCHES } catch(...) { flat_catch( [&]() { throw;
#define CATCH_IF(T,C) } , [&]() { try{ throw; } catch(T) { if(!(C)) throw;
#define END_CATCHES   } }

  try
    foo();
  BEGIN_CATCHES
  CATCH_IF(A a, test_a())
    accept_a();
  CATCH_IF(B b, test_b())
    accept_b();
  CATCH_IF(..., true)
    accept_c();
  END_CATCHES
}

class my_error_base : public std::runtime_error { ..... };

// семейство исключений, по одному признаку на класс
class my_dbms_error : public my_error_base { ..... };
  class my_dbms_sql_error : public my_dbms_error { ..... };
class my_network_error : public my_error_base { ..... };

// семейство исключений, по сочетанию флагов
class my_flag1_error : public virtual my_error_base {};
class my_flag2_error : public virtual my_error_base {};
class my_flag4_error : public virtual my_error_base {};

class my_flags_1_and_2_error : public my_flag1_error, public my_flag2_error {};


try {
  .....
  throw my_flags_1_and_2_error(the_connection, other_helpful_stuff);
  .....
} catch(const my_flag1_error& e) {
  const& my_error_base meb = e;  // и извлечём оттуда the_connection и т.п.
  .....
}

void filter_current_exception()
{
  try
  {
    throw;
  }
  catch (const Exception1& ex)
  {
    . . .
  }
  catch (const Exception2& ex)
  {
    . . .
  }
  catch (const Exception3& ex)
  {
    . . .
  }
}

void foo()
{
  try
  {
    do_something_1();
  }
  catch (...)
  {
    filter_current_exception();
  }
}

void bar()
{
  try
  {
    do_something_2();
  }
  catch (...)
  {
    if (some_condition())
    {
      filter_current_exception();
    }
  }
}