Catch statements are being completely ignored

Question

I've run into a situation with some code I inherited... honestly, I believe the code is written correctly, but this error still seems to manifest.

I'll quickly note that the code is cross-compiled from linux to LynxOS, I'm not sure if that can have anything to do with the error.

Basically, in one specific case:

try {
    std::vector<ClassA> x = SomeGeneratingFunction();

    //We get to here fine.  X may be empty/unpopulated though.
    if (x.size() < 1)
    {
        throw(MyException("It crashed."));
    }
}
catch (MyException e)
{
    //Handle it.
}
catch (...)
{
    //Handle it.
}

We throw given the vector is unpopulated, but for some reason the throw bypasses the catch clauses - both of them. It only seems to happen here - though we woudln't usually do it form an if statement scope, but that should be completely irrelevant since its still in the try scope.

PS: The code below is actually the contents of a function, and exceptions come out of the function when called even though they should all be handled by the catch blocks.

Any ideas how this is possible? And yes, this isn't the real code/exception classes, but the exception class is the simple example you'd google of overloading std::exception, and the SomeGeneratingFunction() does return a good vector, even if it is empty. I cannot provide the real code, but this is exceedingly close barring any little typos I may have made writitng it off the top of my head.

Answer 1

Since the catch (...) clause didn't catch the exception, my answer does not solve the OP's problem. But for others that found this question on SO, maybe my answer is useful, because it explains why the first catch failed.

I had a similar issue where my catch(const std::exception& ex) was just not working. It turned out to be a dumb problem in that I was switching between C# and C++ exceptions, and in C# you need to specify new when you throw your exception, while in C++ you normally don't (but you can, but in this case you are throwing a pointer and not a reference). I was accidentally doing

throw new std::runtime_error("foo");

so

catch(std::exception*  ex)

would have caught it but

catch(std::exception& ex)

doesn't. Of course, the solution is just remove the new statement, as that is not the traditional design pattern in C++.

Answer 2

Since you have a spare set of parentheses around the exception object in the throw statement, it looks like a function call. Is there any possibility that you've defined a function called throw? The parameter to the exception constructor keeps this from being a victim of the Most Vexing Parse, but that's a possibility if your actual code differs from your example.