/* main.cpp */ 

#include <iostream>

using namespace std;

/* handle() */

void handle()
 {
  try
    {
     throw;
    }
  catch(int a)
    {
     cout << a << endl ;
    }
  catch(const char *str)
    {
     cout << str << endl ;
    }
 }

/* main() */

int main()
 {
  try
    {
//     throw 12345;
     throw "67890";
    } 
  catch(...)
    {
     handle(); 
    }

  return 0;
 }

class catch_dispatcher {
public:
  template <typename T>
  void operator,(const T& obj) const {
    try{
     throw obj;
    }
    catch(...) {
      handle();
    }
  }

  void handle() const {
    try {
      throw;
    }
    catch(int a) {
      cout << "Error: " << a << endl;
    }
    catch(const char* str) {
      cout << "Error: " << str << endl;
    }
    catch(const std::exception& e) {
      cout << "Error: " << e.what() << endl;
    }
  }
};

#define throw_error catch_dispatcher(),

auto main(int argc, char argv[]) -> int try {
  throw_error 42;
  throw_error "Hello!";
  throw_error std::runtime_error("wow");
  throw_error std::string("Bad");
}
catch(...) {
  cout << "Unhandled exception" << endl;
}

Error: 42
Error: Hello!
Error: wow
Unhandled exception

wiki/Обработка исключений
[...]встречается возможность гарантированного завершения блока кода (finally, ensure). Заметным исключением является Си++, где такой конструкции нет. Вместо неё используется автоматический вызов деструкторов объектов.
[...]
Корректная реализация исключений может быть затруднительной в языках с автоматическим вызовом деструкторов. При возникновении исключения в блоке необходимо автоматически вызвать деструкторы объектов, созданных в данном блоке, но только тех, которые не были ещё удалены обычным порядком. Кроме того, требование прерывания текущей операции при возникновении исключения вступает в противоречие с требованием обязательного автоматического удаления в языках с автодеструкторами: если исключение возникнет в деструкторе, то либо компилятор будет вынужден удалить не полностью освобождённый объект, либо объект останется существующим, то есть возникнет утечка памяти. Вследствие этого генерация неперехватываемых исключений в деструкторах в ряде случаев просто запрещается.

if(file_flush() == not_enough_space)
     fail();

if(file_flush() == not_enough_space)
    if(call_not_enough_space_handler() == successfully_freed_space)
        file_flush();
    else
        fail();

void inner()
{
 some_vector.resize(some_value);
}

void outer()
{
 try
 {
  inner();
 }catch (bad_alloc &a)
 {
  free_some_memory();
  inner();//если исключение вылезет и отсюда - значицца у нас ничего не получилось :(
 }
}

void outer()
{
 retry 
 {
  some_vector.resize(some_value);
 }catch (bad_alloc &a)
 {
  free_some_memory();
 }
}

void outer()
{
 try(1)
 {
  some_vector.resize(some_value);
 }catch (bad_alloc &a)
 {
  free_some_memory();
 }
}

O>немного не по теме но иногда хотелось бы чтобы можно было написать вместо try — retry

...
struct Try { 
    int en,cnt;
    Try() { en=1; cnt=0; }
    operator int() { return en; }
    void handle() { 
        cnt++;
        try {
            throw;
        } catch(EMemory *e) {
            if (cnt==1) gc();
            if (cnt==2) { en=0; throw; }
            //...
        } catch(...) {
            en=0;
            throw;
        }
    }    
    void gc() { /*...*/ }
};

#define TRY for(Try t;t;) { try {
#define END } catch(...) { t.handle(); } }

...

TRY some_work(); END

 try(5)
 {
  host.resolve();
  host.connect();
 }catch (network_error &a)
 {
  sleep(1);
 }

 try(1)
 {
  read_config();
 }catch (config_broken &a)
 {
  restore_from_backup();
 }

struct Policy {
    static Policy* getContextPolicy();
    virtual void handle(int limit) {
        try {
            throw;
        } catch(EMemory *) {
            //...
        } catch(...) {
            //...
        }
    }
};

struct Try { 
    int limit;
    Policy *policy;
    Try(int count,Policy *policy) { limit=count; }
    operator int() { return limit>0; }
    void handle() { 
        if (limit-->0) policy->handle(limit);
        else throw;
    }    
    void gc() { /*...*/ }
};

#define TRY_LIMIT(n) for(Try t(n,Policy::getContextPolicy());t;) { try {
#define END } catch(...) { t.handle(); } }

...
TRY_LIMIT(3) some_work(); END

try
{
work();
}catch
{
repair();
work();
}

O>try
O>{
O>work();
O>}catch
O>{
O>repair();
O>work();
O>}
O>

struct ECritical {};
struct EIgnorable {};

struct Try {
    int stage,limit; 
    enum { Recover=0,Body=1,Success=2,Leave=3 };
    Try(int count) { stage=1;limit=count-1; }
    operator int() { return stage!=3; }
    void step() { if (stage==0) stage=1; stage++; }
    void handle() {
        if (stage<=1) {
            check_exception();
            if (limit>0) { limit--; stage=-1; }
            else throw;
        } else {
            throw;
        }        
    }
    void check_exception() {
        try { throw; } 
        catch(ECritical) { throw; }
        catch(EIgnorable) { } 
        catch(...) { /*unexprected*/ throw; }
    }
};

#define TRY_LIMIT(n) try{for(Try t(n);t;t.step()) { try { switch(t.stage) {
#define RECOVER      case 0:
#define BODY         case 1:
#define SUCCESS      break; case 2:
#define FAIL         }} catch(...) { t.handle(); }}} catch(...) {
#define END_REPEAT   }

...

int ok=0;

TRY_LIMIT(3)
RECOVER { gc(); }
BODY    { some_work(); }
SUCCESS { ok=1; }
FAIL    { ok=0; /*throw;*/ }
END_REPEAT

TRY_LIMIT(3) {
RECOVER { gc(); }
BODY    { some_work(); }
SUCCESS { ok=1; }
FAIL    { ok=0; /*throw;*/ }
}