Unwinding Exceptions (C++)
Go Up to Standard C++ Exception Handling
When an exception is thrown, the runtime library takes the thrown object, gets the type of the object, and looks upward in the call stack for a handler whose type matches the type of the thrown object. Once a handler is found, the RTL unwinds the stack to the point of the handler, and executes the handler.
In the unwind process, the RTL calls destructors for all local objects in the stack frames between where the exception was thrown and where it is caught. If a destructor causes an exception to be raised during stack unwinding and does not handle it, terminate is called. Destructors are called by default, but you can switch off the default by using the
-xd compiler option.
Using RAII wrappers to automatically dispose pointers
If you have local variables that are pointers to objects and an exception is thrown, these pointers are not automatically deleted. This is because there is no good way for the compiler to distinguish between a pointer to data that was allocated for this function only and any other pointer. The class that you can use to ensure that objects allocated for local use are destroyed in the event of an exception is
unique_ptr. There is a special case in which memory is freed for a pointer allocated in a function:
std::unique_ptr<TMyObject> obj(new TMyObject());
In this example, if the constructor of
TMyObject throws an exception, then the pointer to the object allocated for
obj will be deleted by the RTL when it unwinds the exception. This is the only time that the compiler automatically deletes a pointer value for you.