Re: Parameter Modes, In In Out and Out

[Robert Dewar <robert_dewar@my-deja.com>]

In article <UFK56.92519$A06.3377688@news1.frmt1.sfba.home.com>,
  tmoran@acm.org wrote:
> >>> An out parameter is still taken in.
> >>     No, actually, it is not.
> >This is false information.
>   Robert is technically correct about that sentence.  As
noted in the
> unquoted part of my post, by-reference is an exception.  Ada
is a
> language meant to be read by humans, not just compilers,
however.
> Though it may be obvious to a compiler, or a compiler writer,
that a
> particular OUT parameter can be treated as IN OUT, it may be
> confusing to a human reader, and thus should not be done.


This is quite a confusing followup. A by-reference type is NOT
the same thing as a parameter that happens to be passed by
reference (Tom mentioned large arrays, but that has nothing
whatever to do with by-reference types).

A by-reference type is one that is *REQUIRED* to be passed
by reference. A program may definitely RELY on such a parameter
being passed by reference, and it is not flaky, or undesirable,
or bad practice, to rely on this, since it is guaranteed by the
language.

For such types, IN OUT is identical to OUT semantically (this
is NOT the case with large arrays that happen to be passed by
reference).

Tom in his earlier post said

 >>> An out parameter is still taken in.
> >>     No, actually, it is not.

And it is the reply here that I was saying is quite wrong. The
out parameter *IS* "taken in" for a by-reference type and there
is nothing wrong with relying on this (in fact it is quite
common to read at least some part of out parameters, e.g. array
bounds, and this was allowed even in Ada 83).

So this is not a matter of being technically correct, it is an
important part of the language semantics, and should be
properly understood!

Yes, purely as a stylistic matter one may prefer to use OUT to
indicate that the program does not read anything important from
the parameter, where anything important is not necessarily well
defined (for example, it is perfectly normal for a program to
access the tag of an OUT parameter -- and yes, I know, the tag
is not part of the value :-). But that's all this is, a purely
stylistic issue.

In other situations with by-copy types that are not access
types, it is plain wrong (a bounded error) to read an OUT
parameter, so it is really important to understand the
distinction here, and not sweep it under the carpet of
stylistic rules :-)


Sent via Deja.com
http://www.deja.com/