throw Type(args);

error Type(args);

try(CatchType obj)
 {
  ....

  error "error 1";

  ....

  throw "error 2";    

  ....
 }

class TryCatch
 {
  ....

  public:

   void operator () (const char *str); // для типа const char *

   void operator () (std::exception ex); // для типа std::exception

   ....

   void operator () (); // для оставшихся типов
 };

class File : NoCopy
 {
   FileHandle handle;

  private:

   static ErrorType Open(FileHandle &handle,const char *name);

   static ErrorType Close(FileHandle handle);

  public:

   explicit File(const char *name)
    {
     if( ErrorType e=Open(handle,name) ) throw e;
    }

   ~File() noexcept(false)
    {
     if( ErrorType e=Close(handle) ) throw e;
    }
 };

struct CatchType
 {
  void operator() (ErrorType e)
   {
    // печатаем сообщение об ошибке, например
   }
 };

....

try( CatchType catch_obj )
 {
  File file1("name1");
  File file2("name2");

  ....
 
 }

// Дошли до конца блока, сработал деструктор file2, выбросил исключение. При этом был вызван оператор () у catch.
// Дальше пошла раскрутка стека. Сработал деструктор file1. Тоже выбросил исключение. Опять был вызван оператор () у catch. 
// Второе исключение, однако, передало управление на конец деструктора. Т.е. раскрутка стека продолжилась. В конце концов, управление передано на конец try блока.

{
    // near stack root
    SPECIAL_TRY
    {
        write_file();
    }
    SPECIAL_CATCH(not_enough_space x)
    {
        if(try_to_free_space(x.size()))
            return continue_execution;
        else
            return throw_exception;
    };
}

{
    // deep inside stack
    raise(not_enough_space{size}); // may throw or continue
    // at this point we have enough space
}

/* 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;*/ }
}

#define RETRY(ATTEMPTS) for(int try_attempt = 0; try_attempt <= ATTEMPTS; ++try_attempt) try {
#define CATCH(E) break; } catch(E) {
#define DONE }

int _tmain(int argc, _TCHAR* argv[])
{
    RETRY(3)
    {
        if (--argc) throw std::exception("world");
        printf("done\n");
    }
    CATCH(std::exception &e)
    {
        printf("hello %s\n", e.what());
    }
    DONE
    return 0;
}

#define RETRY(ATTEMPTS) for(int try_attempt = 0, max_attempt = ATTEMPTS; ; ++try_attempt) try {
#define REPAIR(E); break; } catch(E) { if (try_attempt == max_attempt) throw;
#define DONE }

int _tmain(int argc, _TCHAR* argv[])
{
    RETRY(3)
    {
        if (--argc) throw std::exception("world");
        printf("done\n");
    }
    REPAIR(std::exception &e)
    {
        printf("hello %s\n", e.what());
    }
    DONE
    return 0;
}

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

void outer()
{
    re:try {
        some_vector.resize(some_value);
    }catch (bad_alloc &a) {
    if( try_free_some_memory() )
        goto re;
    }
}