A function try block is a function whose body consists of a try block with its associated handlers (catch-statements). A function try block is probably most often used in a class constructor. It enables you to catch exceptions that might be thrown by a base class constructor, or by a constructor of a member object. However, unlike ordinary exception handling, the handler of a function-try-block merely catches the exception; it cannot handle it. Why is this? Once a constructor of an embedded object or a base class is thrown, the partially constructed object is destroyed as part of the stack unwinding. The handler, however, lets you throw a different exception than the one it caught, preventing a violation of the exception specification:

 class X{}; //exception classC::C(const string& s) throw (X); // allowed to throw only an exception of type X     try         : str(s) // str's constructor might throw a bad_alloc exception, violating C's exception specification     {             // constructor function body     }     catch (...) //we get here when an exception is thrown during the construction of str or C     {	throw X(); //replace bad_alloc exception with an exception of type X     }

In this example, a string object is first constructed as a member of class C. String might throw a bad_alloc exception during its construction. The function try block will catch bad_alloc exception, and throw an exception of type X, which is the only one allowed for C’s constructor.