C中的静态多维度数组与指针和地址

Question

I'm learning C and got stuck on the following piece of code:

int a[NUM_ROWS][NUM_COLS], (*p)[NUM_COLS], i;
for (p = &a[0]; p < &a[NUM_ROWS]; p++) {
    (*p)[i] = 0;
}

According to the author this is supposed to assign 0 to i-th column of a 2d array.

I understand that in reality it's not rows and columns but a continuous block of memory - pretty much a 1d array where each element is a 1d array. Also: array name is an equivalent of address of the first element of the array (according to the book I'm reading). For 1d arrays it makes sense to me, 1st element can be an int or char or whatever. In 2d arrays however, each element is an array, so again an address of the first element of the array - this time the "inner" one? Does that mean "a[0]" gives the address of the 1st element of an array, and then we use the "&" operator on it? What does that give me, an address of an address? :/

Could someone please explain what's happening here, step-by-step? What's an address here, what's a pointer, etc. I went over a number of chapters on pointers in various C books to compare how authors explain this, but it looks like they use "pointer" and "address" interchangeably.

I tried comparing the contents of all 3, like so:

printf("%d ", a);
printf("%d ", a[0]);
printf("%d ", &a[0]);

but it all had the same value :/

Answer 1

You're pretty much correct about this. And remember, a[b] is equivalent to *(a+b) , and &*x is equivalent to x (assuming x appears in an expression context), so &a[b] is equivalent to &*(a+b) which is just a+b , so &a[0] is just a (again, in an expression context).

In your case, int a[NUM_ROWS][NUM_COLS] is a block of NUM_ROWS*NUM_COLS elements of type int . They are grouped into NUM_ROWS blocks (rows) of NUM_COLS int elements. If you write a[i][j] it's equivalent to *(*(a + i) + j) . The inner dereference doesn't actually perform a memory access, but rather it removes a level of dereference from the data type. You can think of it as a type cast.

When used in an expression context, a becomes an int (*)[NUM_COLS] pointer which points to the first row of a . Pointer addition scales by the size of an element of a , which is sizeof(int [NUM_COLS]) which is NUM_COLS*sizeof(int) .

You will commonly see people talk of array names "decaying" into pointers when used in an expression context. In the one-dimensional case, if you have int b[DIM] , it "decays" into an int * whose value is the address of b . For instance, when passed as an argument to a function, the array isn't passed, but instead its address is passed.

In the two-dimensional case, if you have int a[NUM_ROWS][NUM_COLS] , it "decays" into an int (*)[NUM_COLS] pointer, which is a pointer to an array of NUM_COLS int elements.

In your example, you pass following to printf:

1. a (decays to int (*)[NUM_COLS] )
2. a[0] (decays to int * )
3. &a[0] (this is just &*(a + 0) or a , decayed to int (*)[NUM_COLS] )

The first and last cases are basically the same. The second case differs only in data type. Note that the data type affects pointer addition. When adding an int to a pointer, the int is scaled by the size of whatever the pointer points to.

Also note that your printf formats aren't really correct, since you're passing pointer values where int values are expected. That won't work on all platforms, and most compilers will warn about bad data types for the format string.

The safe way to format an address with printf is with %p . This expects a pointer, so you will be safe if a pointer and an int don't have the same size.

Answer 2

I'm learning C and got stuck on the following piece of code:

Break down each part of the declaration and loop:

int a[NUM_ROWS][NUM_COLS], /* declare an array of int, size NUM_ROWS * NUM_COLS */ 
(*p)[NUM_COLS],            /* delcare pointer to array of int NUM_COLS          */
i;                         /* declare a single int           */
for (p = &a[0];            /* assign 'p' the address of 'a'  */
p < &a[NUM_ROWS];          /* while address 'p' < address a[NUM_ROWS] */
p++) {                     /* advance to next pointer 'p'    */
    (*p)[i] = 0;           /* set value at 'p[i]' = 0        */
}

So you will set the value of the i'th column (or element) in each array of NUM_COLS ints to 0 . You need to initialize 0 < i < NUM_COLS or the behavior will be undefined as i is uninitialized.

A working example may help you step through what is taking place. Basically, your example code is simply providing a way to step through a 2D array using a pointer and a single integer to isolate a column value rather than the more common use of two integers. Using two integers (using i as the column value to set the second column to 0 in each of the rows) you would see:

i = 1;
for (j = 0; j < NUM_ROWS; j++)
    a[j][i] = 0;

Both the code snippet above and your code snippet will accomplish the same thing, the difference being p points (holds the pointer value to) an array of 3 int values. You dereference p (eg *p ) to get the beginning address of any individual row. You must surround the dereferenced p with parenthesis in order to index any individual value in the row because in C operator precedence the [] operator has higher precedence than the '*' operator. (eg you need (*p)[x] instead of *p[x] ).

#include <stdio.h>

#define NUM_COLS 3

int main (void) {

    int a[][NUM_COLS] = {{1,2,3},
                         {4,5,6},
                         {7,8,9}};
    int (*p)[NUM_COLS];
    int i;
    int NUM_ROWS = sizeof a/sizeof *a;

    printf ("\noriginal array:\n\n");
    for (p = a; p < &a[NUM_ROWS]; p++) {
        for (i = 0; i < NUM_COLS; i++)
            printf (" %2d", (*p)[i]);
        putchar ('\n');
    }

    /* set col 1 (2nd col) to zero */
    i = 1;
    for (p = a; p < &a[NUM_ROWS]; p++) {
        (*p)[i] = 0;
    }

    printf ("\nmodified array:\n\n");
    for (p = a; p < &a[NUM_ROWS]; p++) {
        for (i = 0; i < NUM_COLS; i++)
            printf (" %2d", (*p)[i]);
        putchar ('\n');
    }
    return 0;
}

Output

$ ./bin/array_decl

original array:

  1  2  3
  4  5  6
  7  8  9

modified array:

  1  0  3
  4  0  6
  7  0  9

Answer 3

array name is an equivalent of address of the first element of the array

This is not correct, although it is commonly stated. In fact, just like any other designator, a[0] designates an array of type int[NUM_COLS] .

The correct version of the rule is that that the array name expession may be converted to a pointer holding the address of the first element. This happens implicitly in many uses of the array name in an expression, but there are some expressions where it does not happen.

&a[0] is an example of an expression where this conversion does not happen. It gives you the address of the entire array a[0] , in the same way that after int x; then &x gives the address of the int .

The conversion does not happen when the array expression is the operand of & , sizeof , or an increment operator.

In your printf lines, the conversion does happen in the first two, but not the third. Also, they all cause undefined behaviour due to using the wrong format specifier. Supposing you fix this, remember that when you output a pointer like this, you are only outputting part of the story; there's no indicator of the type of the pointer in the output. Although the first two cases are different pointers, they generate the same output in printf.