Re: Containers - nontrivial element access

["Jeffrey R. Carter" <spam.jrcarter.not@acm.nospam.org>]

Maciej Sobczak wrote:
> 
> Imagine I haven an *array* of Person(s) and I do this:
> 
> Swap (People (X).Salary, People (Y).Salary);
> 
> This is Ada.
> 
> (is it value semantics for you, btw?)
> 
> Now I want to do the same with vector.

You can want to do anything, but that's a good way to be disappointed.

Let's deal with the simpler

People (X).Salary := S;

so we're not mislead by the call to Swap.

With an array, there are no operations (subprograms or entries) invoked. 
With a data structure, you must invoke an operation to get at a value 
stored in it. That's what causes the difference. The operations on the 
data structure return values, so modifying them does not change the 
value stored in the data structure.

> In other words, I want to use Ada in the Ada spirit.

No, the Ada spirit is generally to deal with values (as Ada.Containers 
does), not anonymous references, as is common in C/++ and the STL (since 
everything in C/++ is aliased), though one could argue that the addition 
of anonymous access types and values in Ada 95, and its expansion in Ada 
07 (things I don't like; pointers should be as difficult to use as 
possible), changes the spirit.

> If we realize that vector is a generalization of array, is it
> revolutionary to expect that the common functionality should have
> common interface?

If we realize that package Ada.Containers.Vectors is an 
unbounded-sequence data structure (as is Doubly_Linked_Lists), then we 
would not expect anything of the kind. There are hints in the discussion 
and some of the operations that Vectors is intended specifically for an 
array implementation, but an implementation built on top of 
Doubly_Linked_Lists would be perfectly legal and correct. There are 
analogs of array operations, but they are only analogs.

Ada.Containers is quite general and as safe as possible; it is unlikely 
to be appropriate for many applications. It may be that you should write 
your own, with "access Element" prevalent, for your specific needs. If 
not, you'll have to use the syntax and semantics of the existing packages.

-- 
Jeff Carter
"Spam! Spam! Spam! Spam! Spam! Spam! Spam! Spam!"
Monty Python's Flying Circus
53