Re: Teaching new tricks to an old dog (C++ -->Ada)

[Georg Bauhaus <bauhaus@futureapps.de>]

Hans Malherbe wrote:
 
> * in Ada, loop variables (a) are constants and (b) do not exist outside
> of the loop
> 
> This is safer, but limiting.
> In C++ may want to declare the variable outside the loop,
> break out early and use the loop variable. Let me guess: You can't
> break out early in Ada, right?

No, there is all kind of loop control,

     loop_statement ::=
             [loop_statement_identifier:]
                [iteration_scheme] loop
                   sequence_of_statements
                end loop [loop_identifier];

Inside the loop (sequence_of_statements) you can break out
using for example

     exit [loop_name] [when condition];

(And you can start a new nested block inside a loop with a package in it
with a task type in it etc. if that makes sense in a program.)

> * case statements (Ada's equivalent of a switch in C++) are required
>   to handle all possible cases.  Thus it is impossible to forget one.
>   And, of course, there is no "break;" crap in Ada.
> 
> Prevents fall through.

Yes, no fall through in "case ... end case", which is why case and
switch are not exactly equivalent. There is nice grouping of cases.
You can write fall through switches though, when necessary,
or desirable, only they won't look like a case distinction.


> A few other questions:
> 
> Do you have nested functions like Pascal have? Can you access local
> variables? Can you pass pointers to these functions around?

Yes. There are restrictions on pointers to locally allocated objects used
in an outer scope. The restricted items include local functions,
e.g. there are no full upward closures.


> Can you pass non-type parameters (like the number 3.14) to templates?

Yes, formal template parameters include floating point types and values.
 
> Can templates recurse?

No. (Though you can mix recursive subprograms, nesting, and template
instantiation.)

I think that it is *this* fact ("recursive templates"), the "programmability
of a C++ compiler via templates", that allows a C++ programmer to do many
things that otherwise aren't available in the language.
For example, the
  Can_Copy, Can_This, Can_That
idiom is built into Ada, Eiffel, etc. via constraint genericity,
and so doesn't require a "template computing compiler" for constraining.
OTOH, this is a limitation, even though there is a richt set of
"parameter things" in Ada, including types, interface types, values,
subprograms, and packages (templates parameterized by other templates).


> Can you program "const correct"? Eg. if you declare a member function
> as const the compiler will help you not mutate the object or call any
> functions that do.

The const-mechanics are slightly different.
In order to preclude modifications of the object, use parameter modes,
see below.
The analog of the this pointer is passed to a primitive operation,
i.e. a member function. Ada 2005 adds dotted notation in addition to passing
a this-like value. Now,
if a subprogram's parameter modes disallow modifying the "this parameter",
you can't modify the object's state in the subprogram body
(without trickery that is).

> Also, if you pass a parameter as a const reference,
> you will not be able to mutate the object the parameter references.

The passing modes are, in, in out, and out.
They are logical and indeed separate from direct or indirect access to
the values at the processor instruction level. The compiler usually
chooses what it thinks is best when the language leaves this open.

Georg