Question

The following method (in a Visual Studio 2008 ref class) contains a simple error that I thought would be caught – but instead it causes the process to abort with a “Debug Assertion Failed!” message box (msg includes the offending STL vector src line#). This occurs whether compiled in Debug or Release mode. The process in this case is Excel.exe and the method is accessed via COM interop.

Can someone tell me why this error doesn’t get trapped ?

    String^ FOO()
    {
        try {
            std::vector<int> vfoo;
            vfoo.push_back(999);
            return vfoo[1].ToString();  //!!!! error: index 1 not valid
        }
        catch(std::exception& stdE) { // not catching
            return "Unhandled STL exception";
        }
        catch(System::Exception^ E) { // not catching
            return "Unhandled .NET exception: " + E->Message;
        }
        catch(...) { // not even this is catching
            return "Unhandled exception";
        }
    }

Answer 1

In the Debug configuration you’ll get an assert that’s enabled by the iterator debugging feature. Designed to help to find mistakes in your use of the standard C++ library. You can use the Call Stack window to trace back to the statement in your code that triggered the assert. The feature is controlled by the _HAS_ITERATOR_DEBUGGING macro, very few reasons to ever turn that off in the Debug build. Well, none.

In the Release configuration, you’ll run into the Checked Iterators feature, part of the Secure CRT Library initiative introduced at VS2005 and controlled by the _SECURE_SCL macro. It has a hook built in to get the debugger to stop, much as the above, to show you why it bombed. But not without a debugger, if none is attached then it immediately terminates your program with SEH exception code 0xc0000417. That’s kinda where the buck stops, the DLL version of the CRT was built with _SECURE_SCL in effect and you have no option to not use that DLL when you write managed code. Building with /MT is required to completely turn it off and that’s not possible in C++/CLI.

This tends to drive C++ programmers pretty nutty, catch (…) {} is a blessed language feature even though the odds of restoring program state are very close to zero. There is a back-door however (there’s always a back-door), the argument validation code emits the error condition through a function pointer. The default handler immediately aborts the program with no way to catch it, not even with SetUnhandledExceptionFilter(). You can replace the handler with the _set_invalid_parameter_handler() function. That needs to be done by your Main() method, something like this:

#include "stdafx.h"
#include <stdlib.h>

using namespace System;

#pragma managed(push, off)
void no_invalid_parameter_exit(const wchar_t * expression, const wchar_t * function, 
                               const wchar_t * file, unsigned int line, uintptr_t pReserved) {
    throw new std::invalid_argument("invalid argument");
}
#pragma managed(pop)

int main(array<System::String ^> ^args)
{
    _set_invalid_parameter_handler(no_invalid_parameter_exit);
    // etc...
}

Which will run one of your catch handlers. The managed one, leaving no decent breadcrumbs to show what happened, but that’s normal for native C++ exceptions.