Re: type access Parent'Class

[Yukicanis <yukicanis@googlemail.com>]

On Nov 21, 8:25 pm, Adam Beneschan <a...@irvine.com> wrote:
> On Nov 21, 11:03 am, Yukicanis <yukica...@googlemail.com> wrote:
>
>
>
>
>
>
>
>
>
> > Dear Group,
>
> > I'm new to Ada and currently playing around with its OOP features.
> > Now, I have the following source:
>
> > procedure Test is
> >   type Parent is tagged limited null record;
> >   type Parent_Access is access Parent'Class;
> >   A : access Parent'Class;
> >   B : Parent_Access;
> >   procedure Dyn_Disp(X : access Parent'Class) is
> >   begin
> >     A := X;
> >     B := X;
> >   end Dyn_Disp;
> > begin
> >   null;
> > end Test;
>
> > When I try to complie that with GNAT 4.6.1 I get the following error
> > message:
>
> > test.adb:9:10: expected type "Parent_Access" defined at line 3
> > test.adb:9:10: found type access to "Parent'Class" defined at line 6
>
> > which I don't really understand since type "Parent_Access" is type
> > access to Parent'Class, isn't it?
>
> > Thanks in advance.
>
> Ada is a strongly typed language.  That means that you can have two
> types that look exactly the same but are still different types,
> because you've declared them as different types, and you can't just
> use them interchangeably.  Example:
>
>   type Acc_Type_1 is access all Integer;
>   type Acc_Type_2 is access all Integer;
>   V1 : Acc_Type_1;
>   V2 : Acc_Type_2;
>
>   V1 := V2;     -- ILLEGAL!
>
> This is illegal because V1 and V2 have different types, even though
> the types look the same.  You have to use a type conversion:
>
>   V1 := Acc_Type_1(V2);  -- LEGAL
>
> This doesn't have anything to do with access types, by the way.  All
> types in Ada are like that.
>
> In your original example, "access Parent'Class" is an anonymous type,
> and every time an anonymous type occurs, it's a new type.  So that's
> why
>
>   B := X;
>
> is illegal.  You have to use a type conversion:
>
>   B := Parent_Access(X);
>
> That still won't quite work, because anonymous access types are
> "general" access types and their values can point to any aliased
> Parent'Class object.  However, Parent_Access is called a "pool-
> specific" access type because it can only point to objects that are
> allocated with "new".  To make Parent_Access a general access type,
> add an "all":
>
>   type Parent_Access is access all Parent'Class;
>
> and now your example will compile.  In my view, there isn't much
> reason *not* to use "all" in an access type declaration, and I've
> gotten in the habit of including it routinely.  (But you can't use
> "all" like this if it's not in a TYPE declaration.)
>
> The language allows
>
>   A := X;
>
> even though A and X have different types, because there's no way to
> write a type conversion.  This is an exception to the strong-typing
> rules.
>
> Hope this helps,
>
>                          -- Adam

Yes, that helps me a lot! That you very much!

BTW, I just discovered that

    B := A.all'Access;

also seems to work (with access all). But won't the rigth hand side
result in an anonymous type again?

Thanks in advance.