Re: GCC 4.0 Ada.Containers Cursor danger.

[Matthew Heaney <matthewjheaney@earthlink.net>]

"Dmitriy Anisimkov" <anisimkov@yahoo.com> writes:

> So Ada.Containers is an "Adaified STL". 

Yes.


> Cursors in the C++ STL looks normally, because it looks like high
> level analog of the pointer arithmetic.

The pointer arithmetic in C conforms to the "machine model."  Iterators
in the C++ STL look like pointer arithmetic, because both follow the
machine model.

You can do pointer arithmetic in Ada too (see System.Storage_Elements),
so there's nothing special about C++ here.


> I don't think that such analog should be ported into Ada, where was no
> pointer arithmetic due to the safety reasons.

But Ada does support pointer arithmetic.

If you don't like the design of the Ada standard container library, then
you should have submitted a proposal sans cursors 2 years ago.


> I think [that if] runtime checks of the Ada cursors are worse, then do
> not use the cursors at all.

But didn't just complain that there were too few checks?  Do you want
the library to detect dangling cursors, or not?

I can only speak about the GCC implementation (I am its author), but the
overhead of a cursor compared to the overhead of a raw access type is
minimal.

I have recently started adding additional checks to detect dangling
cursors, that are enabled via pragma Assert.

You don't have to guess about whether using a cursor instead of an
access type is less efficient, since you can just read the sources
yourself.  You can get the sources from either of these sites:

<http://charles.tigris.org/>
<http://gcc.gnu.org/>


> If programmer wants to keep pointer to container elements in the
> somewhere else, he should put elements into container dynamically
> allocated, and have an access to it whereever he need.

You appear to not understand the machine model, upon which the library
is based.  I recommend reading about the design of the STL.

I thought you didn't like things that aren't safe?  Your suggestion to
use raw access types is *less* safe than using cursors, since the
programmer would have to assume responsability for memory management.

Of course, the current library design doesn't preclude your approach.
If you don't like cursors, then don't use them...