Re: Constructing an object

[Matthew Heaney <matthewjheaney@earthlink.net>]

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

> Let's say I have the following:
> 
>     type Color is (Black, Red, Green, Blue, White);
> 
>     type Shape is tagged record
>        C : Color;
>     end record;
> 
>     type Rectangle is new Shape with record
>        A, B : Positive;
>     end record;


If you want greater control of object creation and initialization, then
you could make the types private:

package Shapes is
   type Color is ...;
   type Shape is tagged private;
   type Rectangle is new Shape with private;

   function New_Shape (C : Color) return Shape;
   function New_Rectangle (C : Color) return Rectangle;
   -- other ctors with dif't params as desired
private
   type Shape is tagged record ...;
   type Rectangle is new Shape with record ...;
end Shapes;


> 1. By procedure, which is a primitive operation for each type in the
> hierarchy, for example:

Use a function.  In Ada 2005, you can use a function even for limited types.


> 2. By function:
> 
>     function New_Shape(C : in Color) return Shape is
>        S : Shape;
>     begin
>        S.C := C;
>        return S;
>     end;

Yes, use a function.  However (and I'm really thinking of controlled
types here) you might want to use aggregate syntax:

   function New_Shape (C : Color) return Shape is
   begin
      return Shape'(C => C);
   end;

In Ada 2005, you'll be able say (I don't know if my syntax is quite
right):

   function New_Shape (C : Color) return Shape is
   begin
     return S : Shape do
        S.C := C;
     end return;
   end;


>   function New_Rectangle(A, B : in Positive; C : in Color) return
> Rectangle is
>        R : Rectangle;
>     begin
>        Shape(R) := New_Shape(C);   -- is this OK?

I think this is legal; it's called a "view conversion."


>        R.A := A;
>        R.B := B;
>        return R;
>     end;
> 
> This does not please me for the same reason - no enforcement of proper
> initialization, if a given type makes no sense uninitialized.

But that's because you didn't declare the type in such a way that
initialization is enforced.  You have a few possibilities, including
declaring the type as private, declaring it as private and with an
unknown discriminant, declaring it with a known discriminant, or giving
the record components default values.  


> What approach do you actually use in the real (non-tutorial) code?
> Are there other techniques?
> (I'm aware of the controlled types, but I need to provide parameters for
> construction, which the special Initialize procedure does not have.)

Not quite.  You can combine a function as above, but make the type
controlled.  Something like:

package Shapes is
   type Shape is tagged private;
   function New_Shape (C : Color) return Shape;
private
   type Shape is new Controlled with record
      C : Color;
   end record;

   procedure Initialize (S : in out Shape);
end;


package body Shapes is
  function New_Shape (C : Color) return Shape is
  begin
     return Shape'(Controlled with C => C);
  end;