The exception handling (EH) mechanism disables the possibility of passing a thrown exception by reference or through a pointer. This is due to the way this mechanism is implemented: when an exception is thrown, the mechanism first searches for an appropriate handler in the current scope. If such handler does not exist, all local objects are destroyed, the exception object itself is copied on the stack of the function that is higher in the calling chain, and only then is the current scope exited. This process is very similar to a sequence of return statements, each returning the same object by value to its caller. The “stack unwinding” process is iterative and continues until an appropriate handler has been found or else the program terminates. Why is it still useful to declare a handler as if it caught an exception by reference? Simply, in order to allow a handler to catch any exception derived from the specified type:

 class ExBase {/*_*/};class FileEx: public ExBase {/*_*/};void Write(FILE *pf) {if (pf == NULL) throw FileEx(); }void main (){try { Write(NULL); //will cause a FileEx exception to be thrown }catch(ExBase& exception) {//catch ExBase or any object derived from it--by value//diagnostics and remedies}}

Of course, copying objects repeatedly is a costly process but it occurs only when an exception is thrown–something that should happen in abnormal and rare conditions, during which performance is negligible, compared to application’s integrity and correctness.