Re: type access Parent'Class

[Adam Beneschan <adam@irvine.com>]

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