Representing a two-dimensional array assignment as a pointer math?

Question

I have an array ex:

int array[3][5];

If I want to assign a value to an element in that array, it's simple... ex:

array[1][2] = 8;

However, I want to represent it in a pointer math, would this be correct?

**(array + 5 * 1 + 2) = 8;

In both cases it's looking for the 7th position... I'm just not sure if I need to include the 2nd * outside of (code)

**(code)

EDIT: Just a bit of a follow up. Thank you to everyone who was helping me with this. The confusion that I had came from a mistake in instructor's notes, and after I presented the information you've provided he realized the mistake and agrees that

*(*(array+row)+col) 

or

*(*array+MAX_COL*row+col) 

is the accurate pointer math representation for a two-dimensional array.

The **(array+MAX_COL*row+col) is like array[MAX_COL*row+col], which is used in single dimensional array implementation of multidimensional array, just like James Kanze mentioned in one of the replies to this post (the second one is faster than the first one).

Answer 1

First thing you need to know is that two dimensional arrays aren't pointers to pointers. They're contiguous in memory, so you can represent them by a pointer to T (T is the base type):

int arr[3][5];
int *p = &arr[0][0];

int array_1_2 = *(p + 5 * 1 + 2);

Answer 2

array[1][2] equals *( *(array + 1) + 2).

Answer 3

An example to demonstrate pointer Arithmetic operations synonymous to accessing an Array.

#include<stdio.h>

int main()
{
int array[3][5] = {0};
array[2][3] = 5;
printf( "%d\n",array[2][3]);
printf( "%d\n",*(*(array+2)+3) );
return 0;
} 

Answer 4

There are a couple of wrong assumptions in you question: for example, array[1][2] isn't looking at the 7th position; it's looking at the third position in the second array element of array. The type of array is array[3] of array[5] of int; when it converts to a pointer, the resulting type is a pointer to array[5] of int, not a pointer to int. So array + 5 * 1 + 2) refers to the eighth element of an array with only 5 elements; i.e. 35 * sizeof(int) beyond the start of array (and the expression still has type pointer to array[5] of int).

As a general rule, if you want to simulate access into a multidimensional array, you should declare a single dimensional array:

int array[columns * rows];

If you do this, then *(array + i * columns + j) will effectively perform a 2 dimensional indexing.

Answer 5

An alternate representation would be

*(array[1]+5)=8

---

Let me explain simple analogous code.

int *p[5];

Here p is a pointer that points to the address of first element and p is equivalent to &p[0].

To understand this take an example

#include<iostream.h>    
void main()
{    
int *p[2];
int a=0,b=1;
p[0]=&a;p[1]=&b;
cout<<*p<<endl<<&a<<endl;
cout<<*(p+1)<<endl<<&b<<endl;
cout<<p<<endl<<p+1<<endl;
cout<<**p<<endl<<**(p+1);    
}

The output of the above code is

0x8fbdfff0
0x8fbdfff0
0x8fbdffee
0x8fbdffee
0x8fbdfff2
0x8fbdfff4
0
1

---

In our case int array[3][5] is equivalent to int *p1[5] int *p2[5] int *p3[5]. where p1,p2,p3 represent pointers point to the first element of first second and third row respectively.

So in effect we can consider array[3] as a pointer and array[1]equivalent to p1 similarly array[2] and 3 Hence to get the value of array[1][2] we can use *(array[1]+2) or ((array+1)+2) or considering it is implemented in row major form *(array+1) is equivalent to array+1*5 and you get
*(array+1*5+2)

Answer 6

With the following array:

const int ROWS = 3;
const int COLS = 5;
int arr[ROWS][COLS];

although arr points to the memory, where the first element resides, its type is not int* thus incrementing this pointer won't move you to the second int. So this line:

arr[1][2] = 8;

can be replaced by:

*((int*)arr + 1*COLS + 2) = 8;

or you can use the fact, that this array resides within the continuous block of memory, size of which is equal to ROWS * COLS * sizeof(int), therefore you can simply retrieve the pointer to the first element and use it for this purpose:

int* pFirstEle = &arr[0][0];
*(pFirstEle + 1*COLS + 2) = 8;

But note that this is wrong:

**(arr + 1*COLS + 2) = 8;