Re: Constructors/Destructors in Ada95

[dmitry6243@my-deja.com]

In article <39F8A2CB.CA319F5@averstar.com>,
  Tucker Taft <stt@averstar.com> wrote:
> mark.biggar@trustedsyslabs.com wrote:
> > ...
> >
> > One of the problems with this proposal (redefineing ":=") is that
> > you would have to define Initialize, Adjust and Finialize anyway
> > as you need them to implement value parameter passing, temporary
> > creation and function return values correctly.  Each of those is
> > like assingment, but not exactly the same being, built out of the
> > three primitives in different ways.  So it makes more sense to just
> > define the three primitives and have the compiler generate
> > standard usage sequences then to redefine ":=" and have strange
> > and hard to understand things happen.
>
> This is part of the reason we did not allow the user
> to directly define ":=".  Another important reason has to
> do with assignment of composite objects (e.g. records
> and arrays) containing objects with user-defined
> assignment.  One desirable feature is that the assignment
> for a record, for example, is defined in terms of the
> assignment of its individual components.  Unfortunately,
> there are cases of record assignment in Ada where
> the left-hand-side doesn't contain a component that
> the right-hand-side does.  This happens if the left-hand-side
> is an unconstrained record with discriminants, and the
> right-hand-side happens to have different values for the
> discriminants than the values of the left-hand-side.
> As a result of the assignment, some components of the
> left-hand-side may disappear, and some may come into existence.
>
> For example:
>
>     type Rec(B : Boolean := False) is record
>         X : Cool_Controlled_Type;
>         case B is
>             when True =>
>                Y : Fancy_Controlled_Type;
>             when False =>
>                Z : Another_Controlled_Type;
>         end case;
>     end record;
>
>     R1 : Rec;  -- Defaults to B => False
>     R2 : Rec(B => True);
>
>      ...
>
>     R1 := R2;  -- R1.Z disappears, R1.Y is created,
>                --  R1.X overwritten
>
> It would be tricky at best to define how or whether
> user-defined ":=" for Cool_, Fancy_, and Another_Controlled_Type
> should be used in the above case.

[...]

I think that an assumption that Adjust should be generated from
user-defined ":=" is wrong, or at least very hard to implement.

IMO, used-defined ":=" should have no special semantic. It is not an
alternative to the copy constructor (= copy + Adjust).

The single link between them is that the default ":=" is generated as
Finalize, copy, Adjust.

In the given example, the compiler should simply ignore ":=" defined for
the types of Rec's components.

Another question is, whether copy constructor should be splitted into
block-copy and Adjust.

--
Regards,
Dmitry Kazakov


Sent via Deja.com http://www.deja.com/
Before you buy.