Re: Constructors/Destructors in Ada95

[Tucker Taft <stt@averstar.com>]

Francois Godme wrote:
> ...
> 
> To Tom Moran, I will say that the problem in the Ada.Finalization package
> is the Initialize procedure.

It is a mistake to think that the Initialize procedure
represents Ada's "constructor" feature.  As you recognize
below, Initialize is the rough equivalent of the default
constructor.  For any other kind of constructor, you simply
write a function, or procedure with an [in] out parameter.
Ada also has a builtin constructor to simplify the
creation of these user-defined constructors, namely an aggregate
(array, record, or record extension).  This is available
for non-limited types, in places where the type is
visible (e.g. inside the package where it is declared).  

An aggregate constructor can be combined with dynamic
storage allocation, via an initialized allocator.

For (inherently) limited types, non-default construction must be 
done essentially one component at a time, even when inside
the package where the type is defined.  Of course, from outside
the package, an appropriate procedure would be called to
invoke the user-chosen construction operation, and that
procedure would take care of the appropriate component-by-
component actions.

> 
> The procedures Adjust and Finalize do not cause any problems. But the
> Initialize procedure does not respect the Ada style guide for the same
> reason as above. The Initialize procedure is inherited. And worst, besides
> the object itself to initialize, there are no other parameters passed to
> initialize the object. It is like if in C++, all classes were forced to
> have a default constructor and the instances were first initialized to
> useless values.

Initialize is exactly the part of the default constructor,
over and above the default initialization specified within
the type declaration itself.  If the type extension adds
more components that have default initialization, these
default initializations will occur, even if Initialize is
inherited.  In fact, I would generally recommend that
programmers minimize the use of Initialize, if they can
do it all with per-component default initialization.

But the key point is not to think of "Initialize" as
a general purpose constructor.  It is simply the default
"constructor" (and really only part of that, given the
per-component defaults that are applied first).
"Regular" functions and procedures are used to do
any other "construction."
> 
> That's why the Ada style guide goes on to state: "Consider splitting the
> initialization and construction of an object."

They should probably say consider splitting
*default* initialization and *explicit* construction.
This is only really *necessary* for limited types.
For non-limited types, using a function to initialize
the object upon declaration/dynamic allocation is
quite appropriate.

-- 
-Tucker Taft   stt@averstar.com   http://www.averstar.com/~stt/
Technical Director, Commercial Division, AverStar (formerly Intermetrics)
(http://www.averstar.com/services/IT_consulting.html)  Burlington, MA  USA