Re: Freeing Pointers to classwide types

[Matthew Heaney <matthew_heaney@acm.org>]

tmoran@bix.com (Tom Moran) writes:

> > the normal coding would be to do a free operation in the
> >finalization routine
> I'm unable to see a way to code such a finalization routine:
> procedure Finalize(X : in out T) is
> begin
>    -- some code that frees the memory of X if it's on the heap 
>    -- and nulls out the (any) pointer to X
> end Finalize;

No.  You have to take the deallocation up a level, by wrapping the
allocation in a finalizable type.  A while back I posted an example like
this:

procedure Do_Someting (Stack : access Root_Stack'Class) is

   Handle : Iterator_Handle (Stack);

   Iterator : Stack_Iterator renames Get_Iterator (Handle).all;

begin
...

The type looks like

package Stacks is
...
   type Stack_Iterator is 
      abstract tagged limited null record;
   
   <primitive ops for Stack_Iterator>

   type Stack_Iterator_Access is 
      access all Stack_Iterator'Class;

   type Iterator_Handle (Stack : access Root_Stack'Class) is 
      limited private;

   function Get_Iterator 
     (Handle : Iterator_Handle) return Stack_Iterator_Access;

private

   function New_Iterator 
     (Stack : access Stack_Iterator) return Stack_Iterator_Access;

   type Iterator_Handle (...) is 
      new Limited_Controlled with record
         Iter : Stack_Iterator_Access := New_Iterator (Stack);
      end record;

   procedure Finalize (Handle : in out Iterator_Handle);

end;

package body Stacks is 

   procedure Finalize (Handle : in out Iterator_Handle) is
   begin
      <free Handle.Iter>
   end;

end;

                 
Never let a client call allocator new directly.  Let the allocation be
done by a controlled object, so that when the object is finalized, it
automatically reclaims the memory.