How to use pointer expressions to access elements of a two-dimensional array in C?

by

Summary: If you have a multidimensional array defined as int [][], then x = y[a][b] is equivalent to x = *((int *)y + a * NUMBER_OF_COLUMNS + b);

Boring Details:

The (int *) cast of y above deserves some explanation, as its necessity may not be at-first intuitive. To understand why it must be there consider the following:

  1. Typed pointer arithmetic in C/C++ always adjusts the typed pointer value (which is an address) by the size of the type in bytes when adding/subtracting/incrementing/decrementing by scalar.

  2. The fundamental type of a multi-dimensional array declaration (not the element type; the variable type) is an array-type of one-less dimension than the final dimension.

The latter (#2) of these really needs an example to solidify. In the following, variables ar1 and ar2 are equivalent declarations.

int ar1[5][5]; // an array of 5 rows of 5 ints.

typedef int Int5Array[5];  // type is an array of 5 ints
Int5Array ar2[5];          // an array of 5 Int5Arrays.

Now the pointer arithmetic part. Just as a typed structure pointer can be advanced by the size of the structure in bytes, so can a full dimension of an array be hopped over. This is easier to understand if you think of the multi-dimensioned array as I declared ar2 above:

int (*arptr)[5] = ar1; // first row, address of ar1[0][0].
++arptr;               // second row, address of ar[1][0].

All of this goes away with a bare pointer:

int *ptr = ar1; // first row, address of ar1[0][0].
++ptr;          // first row, address of ar1[0][1].

Therefore, when doing the pointer arithmetic for two-dimensional array, the following would NOT work in getting the element at [2][2] of a multi-dimensioned array:

#define NUMBER_OF_COLUMNS   5
int y[5][NUMBER_OF_COLUMNS];
int x = *(y + 2 * NUMBER_OF_COLUMNS + 2); // WRONG

The reason is hopefully obvious when you remember that y is an array of arrays (declaratively speaking). The pointer arithmetic of adding the scaler (2*5 + 2) to y will add 12 rows, thereby computing and address equivalent to &(y[12]), which is clearly not right, and in fact, will either throw a fat warning at compile time or outright fail to compile altogether. This is avoided with the cast of (int*)y and the resulting type of the expression being based on an bare pointer-to-int:

#define NUMBER_OF_COLUMNS   5
int y[5][NUMBER_OF_COLUMNS];
int x = *((int *)y + 2 * NUMBER_OF_COLUMNS + 2); // Right!

More Related Contents:

  1. Array to pointer decay and passing multidimensional arrays to functions
  2. Pointer address in a C multidimensional array
  3. Passing a 2D array of structs
  4. Are a, &a, *a, a[0], &a[0] and &a[0][0] identical pointers?
  5. C pointer to array/array of pointers disambiguation
  6. How do pointer-to-pointers work in C? (and when might you use them?)
  7. Pointers in C: when to use the ampersand and the asterisk?
  8. Is NULL always zero in C?
  9. What does the ‘array name’ mean in case of array of char pointers?
  10. Post-increment on a dereferenced pointer?
  11. constant pointer vs pointer on a constant value [duplicate]
  12. What exactly is meant by “de-referencing a NULL pointer”?
  13. Pointer to pointer clarification
  14. Need of Pointer to pointer
  15. Is NULL always false?
  16. Does the size of pointers vary in C? [duplicate]
  17. What is the meaning of “wild pointer” in C?
  18. Pass a two dimensional array to a function of constant parameter
  19. Explain this implementation of malloc from the K&R book
  20. using printf to print out floating values
  21. Confusion regarding modification of const variable using pointers
  22. How to check if a pointer is valid? [duplicate]
  23. Is it possible to allocate array inside function and return it using reference?
  24. How to define and work with an array of bits in C?
  25. Array of size 0 at the end of struct [duplicate]
  26. Dereference void pointer
  27. Memory map for a 2D array in C
  28. How to check if a pointer is freed already in C?
  29. Casting void pointers
  30. Cast T[][] to T*

Leave a Comment