Re: Throwing VC++ exceptions between modules - it works, but how?
On 27 Jul 2006 04:24:33 -0700, tomthemighty@googlemail.com wrote:
I'm wondering if anyone can point me at any form of documentation,
official or otherwise, on what happens if you throw an exception from
one module built with VC++ and catch it in another. (I'm pretty sure
what will happen if the other module wasn't written with VC++: BOOM!!!)
I understand that structured exceptions are used to implement C++
exceptions in VC++, and the Debug->Exceptions dialog lists one code
which signifies a "C++ exception", so I assume if module A calls a
function in module B which throws a C++ exception, a structured
exception with this code will be thrown. If the calling function has a
C++ exception handler (or compiler-generated stack unwinding code)
there must be an SEH exception filter set at that level.
What I am most curious about is how the calling code figures out the
type of the C++ object that has been thrown. I'm pretty sure I have
seen code where module A throws an object of type MyClass and module B
catches an object of type MyClass, but MyClass isn't exported so the
two modules contain separate types that just happen to have the same
name and the same implementation.
Which is really not very different than the situation with two different
translation units (source files) belonging to the same module (EXE or DLL).
The C++ "one definition rule" (ODR) requires the type look the same
everywhere, and for native code, at least, module boundaries don't
distinguish types with the same name. The major difference is that Windows
doesn't do any run-time linking of modules beyond dealing with explicitly
exported functions and data, so you won't be able to call any non-virtual,
non-inline functions of non-exported classes.
In this case, if I'm remembering
correctly, the C++ exception is actually caught!!! Does this mean that
some sort of checking based on the name of the type is done? It all
seems rather odd.
Sure, exception handling required some degree of type identification
capability even before RTTI was introduced into the language.
The reason for all this curiosity is that I have to deal with a fair
amount of code that throws exceptions across module boundaries. I am
aware that the general advice is "Do Not Do This!!" but this code is
here to stay. I have never seen any bugs whatsoever as a result of
doing this and to be honest this worries me more than reassures me,
because I have absolutely no idea how it works.
I wouldn't say that "general advice" is correct. The only issues are the
usual module boundary issues, and addressing them mostly boils down to
linking everyone to the same CRT DLL.
I have searched far and wide for an explanation of this corner of VC++,
but failed to find anything. I would be very grateful if somebody could
point me in the right direction. Failing that, I guess it's going to
have to be some disassembler work to try and figure out what is going
on.
Looks like someone's done it already:
http://www.codeproject.com/cpp/exceptionhandler.asp
--
Doug Harrison
Visual C++ MVP