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

[Adrien Plisson <aplisson-news@stochastique.net>]

Hans Malherbe wrote:
> 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. Also, if you pass a parameter as a const reference,
> you will not be able to mutate the object the parameter references.

well, this one seems problematic to non-C++ users, and especially to 
Ada users, so i will explain a bit further:

let's have a C++ class:

class T
{
public:
     void dummy() const;
     void dummy2();

protected:
     int field;
};

T myObject;
myObject.dummy(); // here, myObject.field will not change
                   // because dummy is const
myObject.dummy2(); // here, myObject.field may change...

in C++, dummy() should not be able to call dummy2() since dummy2() is 
not const, so it may change the state of the object, which is not 
allowed because dummy() is const.


let's see it the Ada way: we dont use the dotted notation. instead we 
explicitly pass the oject as a parameter, specifying a mode which 
tells what we want to do with the object:

type T is tagged record
     Field : Integer;
end record;

procedure Dummy( This : in T );
procedure Dummy_2( This : in out T );

My_Object : T;
Dummy( My_Object );
Dummy2( My_Object );

since the "This" parameter in "Dummy" is declared with mode "in", we 
cant assign a value to any field of "This": "This" will then be 
constant. also, "Dummy" cannot call "Dummy_2" passing it its "This" 
parameter: "Dummy_2" requires to be able to assign to "This", but 
"This" is constant in "Dummy".

so the answer is : yes, we can enforce constness in Ada. we can even 
express more since we have many parameter passing modes available:
- with in mode, we cant assign to the parameter
- with out mode, we should only assign a value to the parameter (not 
rely on its initial value)(this one is missing in C++)
- with in out mode, we may read and assign the parameter
- with access mode, well, this is a reference passing mode (i find it 
hard to explain the difference with the other modes, someone else may 
take up on this one)

-- 
rien