Re: is exception when others => null; smart?

[Robert A Duff <bobduff@shell01.TheWorld.com>]

Dale Stanbrough <dstanbro@bigpond.net.au> writes:

> Robert A Duff wrote:
> 
> > Finalization can also be used for this purpose, and that's a cleaner way
> > to do it, but finalization is *very* expensive in most Ada compilers,
> > whereas the above "when others" is pretty cheap.
> 
> Are the same costs associated with C++ destructors, or is there
> something peculiar to Ada that causes it to be so expensive?

I don't know the details of C++ well enough to answer that
for sure.

It's interesting that C++ had destructors first, and then added
exception handling, and folks would rend their clothing over the added
complexity of exception handling.

Ada had exception handling first, and then added finalization, and folks
would rend their clothing over the added complexity of finalization.

The truth is that there are interactions between the two features,
and the last one added to the language gets the blame.

I suspect that the total complexity of these features in Ada and C++ is
roughly equal.  And likewise, the difficulty of doing it efficiently.
I think finalization *can* be done efficiently, but it's not easy.
I think the Rational compiler uses an efficient method, but the others
don't (including the one *my* company, SofCheck, sells -- sigh).

The one thing I can think of that is special to Ada is aborts (including
"select-then-abort" statements.  Finalization requires aborts to be
deferred, and that is expensive in many systems.  (I think the fact that
it's expensive is a design flaw in some operating systems, but since I
usually write compilers and not (desk-top) operating systems, I don't
have too much control over that.)  The "abort" issue does not come up
for C++.

- Bob