Re: Throwing exceptions
On Mar 27, 10:49 pm, Andy Champ <no....@nospam.com> wrote:
James Kanze wrote:
On Mar 27, 12:21 am, Andy Champ <no....@nospam.com> wrote:
Ian Collins wrote:
Yet another reason not to use them!
Funny that. I work in the MS compiler, which doesn't
implement exception specifications. So we have to hand
document and check all the exceptions, which is a right
PITA - especially when you add a new exception to some
widely used worker function that's called from half-a-dozen
other functions which are then...
But you really have to do that anyway, if you're serious
about using them. The exception specification is actually a
negative guarantee---it guarantees that you won't see any
exceptions not listed. But it doesn't guarantee that you
will see a specific type of exception when a specific error
condition occurs: that has to be done by hand, with
comments, code review and unit tests.
What I'd like the compiler to do would be to complain if I
threw an unlisted exception, or called a function that threw
one. The exceptions could then be a part of the published
contract, and allow users of the functions to know what to
expect.
But it doesn't work like that. The fact that an exception is
listed in the exception specification doesn't mean that it will
ever be thrown. And of course, knowing to "expect" a particular
exception doesn't really buy you much; you have to know when to
expect it (e.g. the function couldn't open a file, etc.). (Most
of the time, of course, when you know you have to expect a
certain exceptional condition, a return value is a better choice
than exceptions. But there are exceptions, such as in
constructors, where even if a return value were possible, not
using an exception would result in a zombie object, which is
generally worse than having to use a try block rather than
simply test a return code.)
What an exception specification does is promess, as part of the
contract, that there will be no other exceptions. And the only
time I've found this useful is when the guarantee is that there
will be NO exceptions.
And of course, if the compiler sees that you might throw an
exception, but there is an exception specify that doesn't allow
it, it can (and probably should) warn. Making this recursive,
by requiring the compiler to take into consideration the
exception specifications of the functions your function calls,
can't really be made to work, however, for reasons of backwards
compatibility and compatibility with C. (Not to mention
problems with templates.)
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34