Re: Ammo-zilla

["Matthew Heaney" <matthew_heaney@acm.org>]

In article <7uutgd$87h$1@nnrp1.deja.com> , Robert Dewar 
<robert_dewar@my-deja.com>  wrote:

>> that there's a lot of memory leaks in it, which Ada is a lot better for.
>
>
> Now that's an interesting comment, because to me C++ and Ada
> are identical in this particular department, can you explain
> why you think Ada is better wrt memory leaks?


I can't speak for the original poster, but perhaps one reason is that
functions in Ada can return unconstrained array types, eliminating the
need to heap use, and therefore eliminating a source of memory leaks.

I agree with Robert, but I'd go further and say that here C++ is
superior to Ada95, because you can implement true "smart pointers" (by
overriding the dereference operator "->") that reclaim memory
automatically.

You can do something very similar in Ada95 though, by wrapping the raw
access object in a Controlled type and using unary plus to return the
value.  For example:

  type Bool_Exp is abstract tagged limited private;

  type Bool_Exp_Access is access all Bool_Exp'Class;

  -- Here's the smart pointer type:
  type Exp_Handle is private;

  function "+" (Handle : Exp_Handle) return Bool_Exp_Access;


The article "Smart Pointers", in the patterns archive, describes the
technique.

<http://www.acm.org/archives/patterns.html>

(Use the search engine for find the word "smart" in the subject line.)


Perhaps in a future version of the language controlled-ness (or some
other form of garbage collection) can be applied to access types
directly.  For now, the smart pointer idiom isn't too much pain.