Re: Constructing an object

[Matthew Heaney <matthewjheaney@earthlink.net>]

Maciej Sobczak <no.spam@no.spam.com> writes:

> Is it really enough? Consider this:
>
> with Shapes;
> procedure Hello is
>     S : Shapes.Shape;  -- oops, uninitialized Shape
> begin
>     null;
> end Hello;

I should have been more specific.  In addition to declaring the type as
private, you have to either provide a default for the C component of the
Shape record, or privately derive from Controlled and assign C a value
in the Initialize operation.


> It compiles fine (GNAT) and it allows me to declare an uninitialized
> object of private type Shape. The only thing that private type gives me
> is that I cannot tinker with its internals directly. This is good in
> itself, but not enough to save me from having uninitialized objects.

Right.


> I think that the most general approach is with abstract types, 

You don't need abstract types for this problem.  You would only need to
declare the type abstract if you were declaring an interface (indeed, in
Ada 2005 there's even a special keyword for that), for which you're
unable to provide an implemention for some of the operations.


> although
> at the same time it looks like an overkill in simpler cases and not
> without its own problems. In particular, it introduces an artifical
> hierarchy of types (not counting the cases where the hierarchy already
> exists at the design time, like with true Shapes, Animals, etc.).

Right.  In this case, you don't need an abstract type to be the root of
your type hierarchy.


> I miss constructors. The "real" ones. ;-) (no flame intended)

Well, this issue has been discussed for a long time.  In Ada you use a
function for this purpose.  The only snag is if this is a tagged type,
then you have to treat value-returning functions with care.  You
probably want to make the function non-primitive.  (Note that this is an
error in my last post.)  That means either wrap the value-returning
functions in a nested package (or possibly as children), or return a
class-wide type.

The big improvement in Ada 2005 is that there's new syntax for
initializing a return value (I showed it in one of my examles), that you
can use even for limited types.  (Only for limited types?  Hopefully an
ARG member will jump in here and, er, elaborate.)