Re: Finalization

["Adam Beneschan" <adam@irvine.com>]

Philippe Tarroux wrote:

> >This is broken. You allocate a new vector in Process, then a shallow copy
> >of is made in "return 0." Then O is destructed and as a result Finalize
> >kills that vector. The caller receives the shallow copy object with a
> >dangling pointer in the filed X.
> >
> >
> But I don't undestand why it works for the first 7 iteration of the loop
> and crashes only at the 8th.

Because that's what dangling pointer bugs do.  You've deallocated some
data, but somewhere else in your program you still have a pointer to
the data.  This pointer is now invalid.  However, from a
machine-instruction standpoint, most of the data still exists at the
address, so if you try to access the data at that address, it will
still be successful until something else happens to cause the program
to allocate new data at the same address.  Now, if you use your invalid
pointer, you'll get the wrong data, which could cause your program to
crash, or could just cause incorrect data to be read that causes
erroneous results that you can't figure out.  Or worse, you could use
your invalid pointer to *write* data into memory...  I once had a
problem (when using C, but Ada isn't too much better at preventing
this) where I used a dangling pointer to write data, and it ended up
writing over data that belonged to the memory allocator, and---much
worse---it overwrote an address with another legitimate address, which
meant that the memory allocator didn't crash right away but instead
eventually caused things to go haywire several dozen allocations later.
 Bugs like this can take days to track down.

So the bottom line is, dangling pointer bugs are VERY NASTY, and if
there's one in your code (as there is in your example), fix it.  Don't
worry about why it isn't causing a crash or why it's taking a while to
cause one.  Just do it.  Even if your program seems to be working.

Anyway, the "classic" simple way to deal with this sort of problem is
to override the Adjust routine:

    procedure Adjust (O : in out Obj) is
    begin
         if O.X /= null then
            O.X := new Vector' (O.X.all);
         end if;
    end Adjust;

This is the simplest approach, but it may or may not be wasteful in the
context of your application; reference counters are another way, and
there are doubtless other ways to skin the cat.  But you definitely
need to do something to eliminate the dangling pointer problem.

                                -- Adam