Re: Access types as parameters

[Adam Beneschan <adam@irvine.com>]

On Jul 19, 3:57 pm, rickduley <rickdu...@gmail.com> wrote:
> Hi Randy
>
> You wrote:
> > So it is best to avoid the first form unless you have a particular need for
> > dispatching on an access value (which won't happen here, because the
> > designated type is class-wide).
>
> Why then does GtkAda consistently use the first form, i.e.:
> function My_Function (Thing : access My_Type'Class) return Positive;
> for an 'Initialize' function?
>
> It actually uses the form (this for Gtk.Button.Gtk_Button):
> procedure Initialize
>   (Button : access Gtk_Button_Record'Class;
>    Label  : UTF8_String);

Well, for a *function*, using an access parameter can help get around
the rule that you can't have an IN OUT parameter to a function (a rule
that I think is going away in the next revision of the language).  By
making it an anonymous access type, rather than a named access type,
that lets you pass local variables that the function can modify.

For a procedure, there's less reason to do so.  I don't know anything
about GTK, so I don't know why this wouldn't have worked, if all
Initialize is doing is to set up some fields in Button:

procedure Initialize
              (Button : in out Gtk_Button_Record'Class;
               Label  : UTF8_String);

If, on the other hand, Initialize needs Button as an access so that it
can store it in a data structure, then it probably would have been
best to make it a named access type, to ensure that dangling
references aren't stored in that data structure.

If Initialize is an imported routine from a C library---well, in that
case, I guess you do whatever works.  But I'd still think that using
"in out" would have the same effect---the address of the record is
passed.  (In fact, for an anonymous access parameter, the code
normally CANNOT pass *just* an address; there has to be additional
information in case the procedure needs to do an accessibility level
check.  But for a procedure imported from C, the parameter passing
mechanisms may be different.)

Randy is right, and I thought about saying something along those lines
in my first response but decided (maybe unwisely) not to complicate
things.  You don't need to pass an anonymous access parameter if all
you're going to do is modify the accessed object---IN OUT will do.
And if you're going to store the access parameter in a global
structure, you'll get a runtime error if you try to store a dangling
reference, so it's best to use a global access type so that
accessibility level errors are caught at compile time.  There may be
some esoteric situations, other than dispatching, where passing an
anonymous access parameter may be useful: perhaps the procedure can
determine at runtime whether to store an access value or make a copy
of the object depending on the accessibility level, or perhaps the
procedure wants the ability to accept NULL to indicate that there is
no object to modify, or perhaps a procedure takes two access
parameters and sets up the two accessed objects to point to each
other.  But those all seem very unusual, and may be due to an inferior
design anyway.

                                         -- Adam