Ada access vs C/C++ pointers and references

[duggar@mit.edu (Keith H Duggar)]

In the "ADA Popularity Discussion Request" thread, the topic
of C/C++ pointers and Ada access types came up. Here are the
related quotes

Keith H Duggar writes :
> Or are there simply missing features that preclude some
> efficient coding idioms (does Ada have pointers?).

Ludovic Brenta writes :
> Yes, Ada does have pointers.  They're called
> "access types" in Ada.

Dmitry A. Kazakov writes :
> Yes, Ada has pointers, and interestingly, because that
> wasn't design intent, richer than C++ has.
> ...
>
> 5. Ada pointers are transparent to member extraction and
> array indexing. I.e. in Ada "->" and "." are same.

Before I raise my examples and questions please keep in mind
that I do not know Ada. Therefore, I'm purely seeking
knowledge and all my statements about Ada should be regarded
as questions rather than statements.

It seems to me that Ada access types are more akin to C++
references than there are to C/C++ pointers. For by pointer
I literally mean an integral type supporting integer
arithmetic which can be interpreted as a memory address.

In reference to point 5. above, pointer arithmetic is partly
why C++ has both "->" and "."

In C/C++ such pointer arithmetic allows for a number of
idioms intended to produce faster or more efficient code.
For example, consider array subscript access:

    C++ :  x[i]
    Ada :  x(i)

Since both languages allow subscripting by integers that
may not be available until runtime, both C++ and Ada
compilers must produce machine code that effectively:

1) computes the location in memory of x[i] from the location
   of x and the value of i
2) "dereferences" that location for either read or write (by
   loading into a register, etc)

Pointer arithmetic in C/C++ sometimes allows you to skip
step 1 by keeping and updating the address directly. For
example, consider the following two examples which both
process all the characters of a null terminated array.

    char buffer[80]

    // read in some contents into buffer

    // method one
    for ( int i = 0 ; buffer[i] != '\0' ; ++i ) { ... }

    // method two
    for ( char * cp = buffer ; *cp != '\0' ; ++cp ) { ... }

Here are the operations performed during each pass of the
loop

method one :  increment i
              compute address of buffer[i]
              dereference address of buffer[i]
              compare to null '\0'

method two :  increment address (pointer) cp
              dereference address cp
              compare to null '\0'

As you can see, method two saves one instruction by storing
and manipulating a memory address directly.

Here is an example of saving space using pointer arithmetic
in a doubly linked list

http://c2.com/cgi/wiki?TwoPointersInOneWord

Now please don't misunderstand me. I'm not advocating these
techniques. Nor do I mean to imply that they are practically
important. Furthermore, allowing pointer arithmetic creates
a host of problems of which I'm sure you are aware.

I'm simply asking four things.

First, is it correct to say that Ada access types ore more
similar to C++ references (T&) than they are to C/C++
pointers (T*) ?

Second, does Ada provide any facilities for direct and raw
memory access by memory address and pointer arithmetic?

Third, if Ada does not provide arithmetic pointers do you
know if this has played any part in acceptance of Ada for
systems programming or efficiency critical applications?

Fourth, have you experienced or can you think of any cases
were pointer arithmetic has helped to solve a problem that
would have been more difficult with Ada access types alone?

Keith