Re: virtual destructors

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

tmoran@acm.org writes:

> > Another question: are there any advantages in using
> > Ada.Finalization for objects that will always be dynamically
> > allocated/deallocated over simply declaring a Dispose procedure,
> The compiler will make sure Finalize is called, whereas the programmer
> will sooner or later forget to call Dispose.

But the Finalize is just doing some Unchecked_Deallocations (according
to the OP), so it doesn't really matter.  If you forget to Dispose,
then it will Dispose just before program exit, which is not really
useful.

If the Finalize were doing something important, then yes, the Ada
implementation makes sure it happens.  But for library-level access
types (which is 99.9% of all access types, I suspect), it happens very
late in the game if you don't explicitly Dispose.

I think the truth is that finalization is much more useful for stack
objects than for heap objects.  In Java, where everything's a heap
object, and deallocation is done by GC, finalization (quite a complex
feature) is nigh unto useless, which is rather a shame.  You can't do
most of the useful tricks that Ada and C++ allow, like locking/unlocking
a resource via finalization.

- Bob