multidimensional array = pointer to pointer ?

[Kobu]

I've read the FAQ and several posts on multidimensional arrays and how
their names decay to pointer to arrays (not pointer to pointers).

If this is so, why does the following code fragment compiler and run
correctly?:


#include <stdio.h>

int main()
{
int example[4][4]={ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16};

printf("\nBEFORE DOUBLE DEREFERENCING of example:\n");
printf("\nexample[0][0] = %d\n",example[0][0]);


**example = 100; /* double dereferencing 'example' */


printf("\nAFTERDOUBLE DEREFERENCING of example:\n\n\n");
printf("\nexample[0][0] = %d\n",example[0][0]);

return 0;
}

The code ('example') behaves just like a pointer to a pointer. Then
why isn't it a pointer to a pointer?

 

[Kobu]

Is this a logical explanation for what I've posted (based on pointer to
array)? ...

1) 'example' points to example[0]

2) *example is example[0]
(and example[0] is another array name, which points to example[0][0])

3) so *(*example) = *(example[0]) = example[0][0]



I see how that works, except for the fact that *example being equal to
example[0], to me, means the physical array example[0], not the just
the name.
Can anyone explain 2) and how the result of *example can be once again
treated as another array name?



With 'ragged' arrays, the above is much more concrete because there is
an intermediate array of pointers to other arrays (so double
dereferencing takes 2 specific paths to the final destination object).

How can double dereferencing take 2 paths with a conventional array?
Some help would be appreciated

 

[Chris Torek]

I've read the FAQ and several posts on multidimensional arrays and how
their names decay to pointer to arrays (not pointer to pointers).
Yes.

If this is so, why does the following code fragment compile and run
correctly?:

Learn to love The Rule See <http://web.torek.net/torek/c/pa.html>
et seq.; pay attention to the distinction between "object" and "value"
and what happens when you put an object in a value context.

[snippage]

int example[4][4]={ /*...*/ };

Here "example" is an object of type "array 4 of array 4 of int".

**example = 100; /* double dereferencing 'example' */

The inner "*example" needs the "value" of "example", so apply The
Rule, obtaining a pointer to its first element. This first element
has type "array 4 of int", so the pointer has type "pointer to
array 4 of int".

The unary "*" operator then follows the pointer, obtaining the
entire "array 4 of int" (example[0][0] through example[0][3]
inclusive). This is an object of type "array 4 of int".

Now we have *(that), so we need the value of that. Once again,
we need the "value" of an array object, so apply The Rule. The
result is a value of type "pointer to int" pointing to the first
element of the entire "array 4 of int". The unary "*" operator
then follows that pointer, obtaining the (single) int to which
it points.

If you look at the figure in <http://web.torek.net/torek/c/pa.html>,
the two steps here are "find the red circle" and then "find the
black circle". Had you written, say:

*(*(example + 2) + 1)

the steps would be: obtain a red circle, move it forward two units
(two "full red circles" worth of distance), then obtain a black
circle within the moved-down red circle, then move *it* -- the
smaller, black circle -- forward one unit.

This is how indexing works in C, and how it is that arrays and
pointers *work* similarly (by obtaining intermediate pointer values
that are not stored anywhere in C's regular object-storage memory).
You can, of course, make your own intermediate pointers and store
them in memory.

 

[E. Robert Tisdale]

I've read the FAQ and several posts on multidimensional arrays and
how their names decay to pointer to arrays (not pointer to pointers).

The use of the word "decay" here is common and unfortunate.
It seems to imply that a pointer is somehow inferior to an array name
or a "degraded" array name.
It might be better and more correct to say that,
"There is an implicit conversion of an array name to a pointer."

If this is so,
why does the following code fragment compiler and run correctly?:

> cat main.c

#include <stdio.h>

int main(int argc, char* argv[]) {
int example[4][4]={{ 1, 2, 3, 4},
{ 5, 6, 7, 8},
{ 9, 10, 11, 12},
{13, 14, 15, 16}};

printf("\nBEFORE DOUBLE DEREFERENCING of example:\n");
printf("\nexample[0][0] = %d\n",example[0][0]);

**example = 100; // double dereferencing 'example'

printf("\nAFTERDOUBLE DEREFERENCING of example:\n\n\n");
printf("\nexample[0][0] = %d\n",example[0][0]);

return 0;
}

> gcc -Wall -std=c99 -pedantic -o main main.c
> ./main

BEFORE DOUBLE DEREFERENCING of example:

example[0][0] = 1

AFTERDOUBLE DEREFERENCING of example:



example[0][0] = 100

The code ('example') behaves just like a pointer to a pointer.

example is an array of four arrays of four int's each.
*example is a reference to array 0 of example (example[0]).
**example is a reference to element 0 of example[0] (example[0][0]).

Then why isn't it a pointer to a pointer?

In general, there is no memory reserved
for an object of type int** named example
nor is any memory reserved for any array of four objects of type int*
to which example points.
example is just the name of an array of four arrays of four int's each.

 

[CBFalconer]

I've read the FAQ and several posts on multidimensional arrays and how
their names decay to pointer to arrays (not pointer to pointers).

If this is so, why does the following code fragment compiler and run
correctly?:

#include <stdio.h>

int main()
{
int example[4][4]={ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16};

printf("\nBEFORE DOUBLE DEREFERENCING of example:\n");
printf("\nexample[0][0] = %d\n",example[0][0]);

**example = 100; /* double dereferencing 'example' */

printf("\nAFTERDOUBLE DEREFERENCING of example:\n\n\n");
printf("\nexample[0][0] = %d\n",example[0][0]);

return 0;
}

The code ('example') behaves just like a pointer to a pointer. Then
why isn't it a pointer to a pointer?

Because the array 'example' is still in scope. Thus *example is a
pointer to an array of 4 ints. **example points to the first of
those 4 ints.

However if you pass example off to another function, things are
different.