Re: Parameter Modes, In In Out and Out

[mark_lundquist@my-deja.com]

In article <93cagm$c1j$1@nnrp1.deja.com>,
  dmitry6243@my-deja.com wrote:
> In article <938p3u$omv$1@nnrp1.deja.com>,
>   Robert Dewar <robert_dewar@my-deja.com> wrote:
> > In article <3A57CD7F.2228BFD5@brighton.ac.uk>,
> >   John English <je@brighton.ac.uk> wrote:
> >
> > > I prefer to consider parameter passing by copy-and-return
> > > rather than by-reference as the norm (even though it applies
> > > to fewer situations in practice)
> >
> > But unfortunately, this model is just wrong for by-reference
> > types. Especially in object oriented programming, where all
> > tagged types are passed by reference, it is quite wrong to
> > regard the input as uninitialized, since this does not
> > correspond with the semantics of the language.
>
> OOP does not enforce "tagged types" to be passed by reference. This is
> Ada 95 specific. Only class-wide types shall be passed by reference
(for
> their size is unknown).

"tagged type" is an Ada locution -- when Robert uses it, you know he is
talking about Ada!  So I think he meant something like, "...in object
oriented Ada programming where you are using tagged types, it is quite
wrong to regard the parameter as uninitialized, since tagged types are
always passed by reference"!

>
> Maybe I am wrong, but it seems that RM does not forbid to keep the
type
> tag separated from the value. Does it?

No, it doesn't; it's just that the tag is not "part of" the value
(regardless of where it is "kept").

>
> Anyway the clear distinction of normal types and class-wide types is
an
> excellent (revolutionaly, IMO) concept. It is pity that Ada 95 didn't
> use all advantages of the concept. For instance, to have multiple
> dispatch, or even, all types "tagged"!

Interesting idea, but I don't know that I agree it's "a pity" that Ada
didn't do these things.  Ada is a practical language.  Making scalars,
etc. carry a tag around wouldn't be worth it.  It would really foul up
system-level programming and interfacing to other languages. I don't
see a whole lot of value in doing classwide programming on integers or
arrays anyway (with plenty of opportunity for obscure code).  Can't you
get the same effect by declaring a tagged container, then deriving from
that?  Use a tagged record if you want taggedness... simple, there's no
loss of power there...

-- mark



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