When is a function try block useful?

Question

I'm wondering when programmers use function try blocks. When is it useful?

void f(int i) try {    if ( i  < 0 )        throw "less than zero";    std::cout << "greater than zero" << std::endl; } catch(const char* e) {     std::cout << e << std::endl; }  int main() {         f(1);         f(-1);         return 0; } 

Output: (at ideone)

greater than zero less than zero 

EDIT: As some people might think that the syntax of function defintion is incorrect (because the syntax doesn't look familiar), I've to say that no its not incorrect. Its called function-try-block. See §8.4/1 [dcl.fct.def] in the C++ Standard.

Answer 1

You use it in constructors to catch errors from initializers. Usually, you don't catch those errors, so this is a quite exceptional use.

Otherwise, it is useless: unless I'm proven wrong,

void f() try { ... } catch (...) { ... } 

is strictly equivalent to

void f() { try { ... } catch (...) { ... } } 

Answer 2

Function try block are useful for me in two contexts.

a) To have a catch all clause around main() allowing to write small utilities without having to worry about local error handling:

int main() try {     // ...     return 0; } catch (...) {     // handle errors     return -1; } 

which is clearly just syntactic sugar for having a try/catch inside main() itself.

b) to handle exceptions thrown by base class constructors:

struct B {      B() { /*might throw*/ } };  struct A : B {      A()       try : B() {           // ...       }       catch (...) {          // handle exceptions thrown from inside A() or by B()       }  };