When athrow expression is evaluated, an exception object is initialized from the value of the expression. The exception object which is thrown gets its type from the static type of the throw expression ignoring anyconst andvolatile qualifiers. For class types this means thatcopy-initialization is performed.

The exception object's scope is outside of the scope of the block where the throw occurs. Think of it as living in a special exception area off to one side of the normal call stack where local objects live.

Inside acatch block, the name initialized with the caught exception object is initialized with this exception object and not the argument tothrow, even if this was an lvalue.

If youcatch via non-const reference, then you can mutate the exception object, but not what it was initialized from. You can alter the behaviour of the program if you re-throw the exception in ways that you couldn't if you caught by value or const reference (const_casts aside).

The exception object is destroyed when the last catch block that does not exit via a re-throw (i.e. a parameterless throw expression evaluation) completes.

The exception object is available only incatch block. You cannot use the exception object outside thecatch block. Following steps happen when you throw an exception and catch:

try{ MyException anObject; throw anObject;  //1}catch(MyException exObject){}

• Thethrow clause (//1) receives the local objectanObject, and treats it as a value argument: it creates a copy of theanObject.
• thecatch handler catches an MyException Object,which again is a value parameter. At this moment another copy is created.
• If thecatch handler would have implemented so as to receive a reference to an object(catch (MyException &o)), the second copy is avoided.
• ifcatch handler receives the exception object byconst& then you can only callconst methods.

First of all, the object you throw goes out of scope almost immediately. What's going to be caught by exception handlers is acopy of original object. That copy will be deleted after catch handler is executedunless you catch it by value (not by reference). In this case there will be another copy created. But you should catch it by reference (preferably const one) anyway.

• c++
• exception
• scope