Re: bitwise comparators

[Keith Thompson <kst@cts.com>]

Jeff Carter <jrcarter010@earthlink.net> writes:
> Keith Thompson wrote:
> > Jeff Carter <jrcarter010@earthlink.net> writes:
> > [...]
> > > C does not have arrays; it only has different notations for address
> > > arithmetic.
> > 
> > That's a slight exaggeration.  C does have array types and array
> > objects.  For example this:
> >     int a[10];
> > declares a as an array of 10 ints, very much like Ada's
> >     A: array(0 .. 9) of Integer;
> > It does not, contrary to popular misconception, declare a as a
> > pointer.
> 
> That would explain why a[0] and *a are different notations for the same
> thing, and a[2], *(a+2), and 2[a] are also different notations for the
> same thing. a[2] is defined as a shortcut for *(a+2), which is why 2[a]
> works. The "array" notation in C is a different notation for address
> arithmetic. I stand by my statement.

C does have arrays; it just defines some of the operations on arrays
in terms of lower-level operations, exposing some of the nuts and
bolts that Ada (wisely, IMHO) hides.

For example, "&a" yields the address of a, and is of type "pointer of
array of 10 ints", not "pointer to int".  Similarly, "sizeof a" yields
the size of the array, not the size of a pointer.  If a structure
member is an array, the full space for the array is allocated in each
object of the structure type, and the structure can be assigned and
passed by copy.

C arrays are *partly* built on the lower-level concept of pointers,
but not entirely.

Section 6 of the C FAQ, at <http://www.eskimo.com/~scs/C-faq/top.html>,
explains this better than I can.

> Meanwhile, in Ada, A (0) and A (2) are legal, but A.all, 2 (A), and (A +
> 2).all give compiler errors.

Which means that Ada arrays are closer to being first-class types than
C arrays are.

-- 
Keith Thompson (The_Other_Keith) kst@cts.com  <http://www.ghoti.net/~kst>
San Diego Supercomputer Center           <*>  <http://www.sdsc.edu/~kst>
Welcome to the last year of the 20th century.