Re: memory leakages with Ada?

["Chad R. Meiners" <crmeiners@hotmail.com>]

"Kevin Cline" <kcline@optelnow.net> wrote in message
> Dereferencing nil is just as fatal to program execution.  The only
advantage
> is that it is more easily debugged because the crash is immediate.
> Any code that keeps invalid pointers around, whether null or not, is
> poorly crafted.  Good programmers don't much care about the state
> of a pointer variable after delallocation because the variable
> is either going to be reassigned immediately or is going out of scope.

While it is true that dereferencing a null pointer will raise a
constraint_error exception, exceptions can be handled gracefully and null
pointers can be guarded against.  Pointers off to nowhere are very difficult
to detect in a general manner.

Your assertion about good programmers not caring about the state of a
pointer, however, is false.  For example, let's say we want to build a hash
table of complex objects.  This can be accomplished via an array of pointers
to the given object type.  Here is a case where we will want to reuse the
pointers (although not necessarily immediately) since we might delete and
add a bunch of objects throughout the program's lifetime.   Here we can
clearly use the state of the pointers to hold valuable information about the
table.  Is this use improper?  No, this is actually a case where using
pointers is the right way to go about solving the problem.   Other examples
of null pointers being useful are linked lists and tree data structures.

This is one of the many reasons why I like Ada.  The designers did a very
good job with access types.  I have never encountered a situation where I
felt I was being forced by the language to use a pointer improperly in the
six years I have been programming with it.  I have found that Ada's design
is embedded with much wisdom; if you ask, "Why does Ada do/have this?", the
answer often makes you a better programmer.

-CRM