Wie wickeln Sie Anrufe mit try/catch-Block?

Question

Angenommen, ich habe verschiedene Funktionen, die Ausnahmen auslösen kann:

const Foo& func_foo(...); // Can throw exceptions 
const Bar& func_bar(...); // Can throw exceptions 
const FooBar& func_foobar(...); // Can throw exceptions 

Ich habe verschiedene Orte in Code, die solche Funktionen in folgenden Weise verwenden:

some_func(/*applying of func_foo or func_bar or func_foobar*/(...)) 

Eigentlich ist Ergebnis bin mit von Funktionen sofort an vielen Stellen innerhalb verschiedener Funktionen.

Was ist der beste Weg, um das Aufrufen von Funktionen von func_foo/func_bar_func_foobar mit try/catch-Block ohne globales Neuschreiben von anderen Teilen des Codes zu umbrechen?

Idealerweise möchte ich, so etwas verwenden

some_func(TRY_CATCH_BLOCK(func_foo(...))); 

catch-Handler Ausnahme wird propagieren (zB func_foo zu nennen) mit verschiedenen Arten

catch (const ExceptionFoo& e) 
{ 
    throw SomeException1("Some message from e"); 
} 
catch (const ExceptionBar& e) 
{ 
    throw SomeException2("Some message from e"); 
} 

Answer 1

Ich muss zugeben, dass ich die Kombination von Lambda-Ausdrücke finden und Makros machen ziemlich viel Spaß.

#define TRY_CATCH_BLOCK(...)   \ 
    [&]() -> decltype(auto) {  \ 
     try {      \ 
      return __VA_ARGS__;  \ 
     } catch(/* ... */) {   \ 
      /* Handle and rethrow */ \ 
     }       \ 
    }() 

Dies kann genau wie Sie angegeben aufgerufen werden, einschließlich Interleaved in einem anderen Funktionsaufruf.

some_func(TRY_CATCH_BLOCK(func_foo(...))); 

See it live on Coliru