Recently I tracked down a crash to an out of bounds index in a STL vector. The strange thing was that the crash was being handled by Windows instead of by our error reporting code, which is designed to trap everything that the explicit exception handlers did not catch.
Obviously it wasn't.
I created some short test code:
vec = 3;
When run under the debugger, I receive a helpful window that says "vector out of range" with the standard Abort/Retry/Ignore debugger options. All very well and good, but there was no exception being thrown.
I tried using set_unexpected(), which turns out didn't mean what I thought it meant. The function set_unexpected() is called when an exception is thrown through a function that doesn't declare that exception in the throw() statement in the function declaration. Visual C++ does not support these declarations, and so does not support set_unexpected(). This is discussed in the documentation
So I tried set_terminate(), which is the only other function under Exception Handling Routines
that seemed relevant. Unfortunately, my termination function was never called. Since my two line program certainly was not catching an exceptions, something else was happening.
I tried running the code again as a Release build instead of a Debug build. It still broke to the debugger, but in a separate place than the Debug build.
I tried reading the documentation
, which makes no mention that operator can throw an exception.
Stranger and stranger. I tried walking the stack with the Release build, which looked like this:
The function _invalid_parameter() had this comment:
// No user handler is defined. Notify the debugger if attached.
So I tried running the Release build without the debugger. Which also yielded no useful information.
I don't remember exactly how I figured out what was happening, but it turns out that STL is throwing "out_of_range", which is derived from "logic_error", which is derived from class "exception". I've been using STL for twelve years. I've written articles about it. And I've never heard of these exception classes. Clearly, the authors of the documentation had never heard of them either.
Note that this behavior is different than other implementations of STL, which specifically document that only the at() functions throws an exception, not operator. At least "out_of_range" is defined in the standard
Visual Studio 2010 behaves according to the standard. In Release builds, vector<>::operator does not do bounds checking and does not throw the out_range_range exception. In Debug builds, an assertion is shown because _ITERATOR_DEBUG_LEVEL is set to 2 in yyvals.h if _DEBUG is defined.]
But the fun wasn't over. I still didn't know why set_terminate() wasn't working. The documentation for Unhandled C++ Exceptions
only discusses set_terminate().
It turns out that unhandled logic_error exceptions are handled by invalid_parameter_handler and not by terminate_handler. This is broadly discussed in the documentation for Invalid Parameter Handler Routine
. However, that documentation describes how errno is set, which doesn't appear to happen with STL.
The situation gets even more murky if you consider Windows SEH (Structured Exception Handling) as well as C++ exceptions. The standard way of dealing with SEH is to use SetUnhandledExceptionFilter(). However, Visual Studio 2008 changes this behavior. See a blog entry
by Jochen Kalmbach. Related information about C-Runtime behavior is discussed in the MSDN forums