Re: some questions re. Ada/GNAT from a C++/GCC user

[bobduff@world.std.com (Robert A Duff)]

In article <leschkes.828053356@ferret>,
Scott Leschke <leschkes@ferret.cig.mot.com> wrote:
>My first question would be, why do you want redundant instantiations.

Usually you don't.  But you might declare a type Apple_Count, and not
know whether anybody wants to do I/O on it.  Then one client does, and
instantiates Text_IO.Integer_IO on Apple_Count.  And another client
independently does the same.  One might like to share the code of the
two instantiations.

But, as Bill Newman pointed out, the more important thing is when you
have Apple_Count and Orange_Count, which are logically distinct, but
happen to share the same hardware representation.  That's a more
important case where you'd like shared generic code.

Shared generic code isn't easy to implement in general, but many Ada 83
compilers support it, at least for some kinds of generics.  The problem
is that you can't count on it in portable code, so you have to do it "by
hand".  That's not so awful, I suppose -- at least the ugly parts are
buried in one place.

>You can use a block statement.  This is different than C++ in the sense
>that objects declared within the block are only in existence within the
>block and are finalized at the end.

No, I think this is exactly the same in C++ and Ada.  See r.6.7 of The
C++ Programming Language, Second Edition, by Bjarne Stroustrup.  That
is, if you declare an object in C++ in a local sequence of statements,
it will be finalized at the end of that sequence.  The only difference
is that Ada requires some extra syntactic baggage.

>declare
>   Obj : Pkg.SomeType;
>begin
>   Pkg.Operation (Object => Obj);
>   -- Other stuff
>exception
>   when Pkg.Some_Exception =>
>
>      Do_Something;
>end;

The exception handler makes this look reasonable, but in the usual case,
where there's no need for any exception handling, and you just want to
declare Obj, the extra 3 lines of code ("declare", "begin", "end") are
just an annoyance.

- Bob