Can't understand exactly the pointers in 2d array - c

Question

I have done something by looking to the internet but something is missing here is my code
void draw_way(int *arr,int lenght_row,int lenght_column) {
int s1 = 0, s2 = 0;
for (s1 = 0; s1 < lenght_row; s1++)
{
for (s2 = 0; s2 < lenght_column; s2++) {
if (*((arr + s1 * lenght_row) + s2) == 1)
{
printf("S");
}
else if (*((arr + s1 * lenght_row) + s2) == 2)
{
printf("G");
}
else if(*((arr + s1 * lenght_row) + s2) == 3)
{
printf("#");
}
else if (*((arr + s1 * lenght_row) + s2) == 4)
{
printf(".");
}
}
printf("\n");
}
it is actually printing a maze but is is not important. The thing I want to understand is why ı had to use *((arr + s1 * lenght_row) + s2) why this is not working if ı use *(*(arr+s1)+s2) what 'lenght_row' does.

Answer 1

For any array or pointer arr and index i, the expression *(arr + i) is exactly equal to arr[i].
If we do this translation for *(*(arr+s1)+s2) that would be (arr[s1])[s2] (or arr[s1][s2]). Since arr isn't a pointer to a pointer (or array of arrays) then arr[s1][s2] doesn't make sense.
Instead you kind of emulate a 2d array (array of arrays) using a array (whose first element is pointed to by arr) and use arithmetic to calculate the single index into this array.
This is very common for dynamically allocated memory, where instead of using a jagged array (using pointers to pointers) you use a single contiguous area or memory.
It might be easier to understand with an illustration...
Lets say we want a 2d array of 2 by 3 elements. We can create it using dynamic allocation as a jagged array:
int **arr;
arr = malloc(2 * sizeof *arr); // First dimension
for (size_t i = 0; i < 2; ++i)
arr[i] = malloc(3 * sizeof *arr[i]); // Second dimension
Since we have multiple allocations, there's no locality in the array, arr[0][2] might not be followed by arr[1][0]. Locality and having the 2d array being contiguous could be good for some algorithm and use-cases.
A contiguous 2d array would be an array of arrays like
int arr[2][3];
but this is harder to handle dynamically, so instead we allocate a single contiguous memory area of 2 * 3 elements:
int *arr;
arr = malloc(2 * 3 * sizeof *arr);
Unfortunately this can't be indexed in the same intuitive way as a jagged array or array of arrays (i.e. arr[0][1] isn't possible). But with some clever arithmetic it is possible: arr[row_index * row_length + column_index] will be like arr[row_index][column_index] (for a jagged array or array of arrays).

Answer 2

arr is a flat array, not a multi-dimensional array. It emulates a mult-dimensional array by way of passing in the grid size. So, if it was 5x2, then arr as a flat array would be 10 integers long, not an array of 5 rows of another array of 2 columns.
Hence, it uses simple pointer arithmetic to emulate the r,c dimensions by way of the flat array index calculation
((arr + s1 * lenght_row) + s2)

Answer 3

if you reduce number of paranthises it will easier to understand: if (*(arr + s1 * lenght_row + s2) == 2)
2D array has c columns and r rows. They are stored in the memory continuously row0 then row 1 them row2 ...
So to access the particular element (row, column) you need multiply row by 'r' (whics is how many elements we hae in the row and add column.

Answer 4

For starters the expression in if-else statements like this
if (*((arr + s1 * lenght_row) + s2) == 1)
is incorrect. There should be
if (*((arr + s1 * lenght_column) + s2) == 1)
The parameter arr declared like
int *arr
has the type int *. So dereferencing the pointer like *arr you will get an object of the type int for which you may not apply the dereferncing operator.
So this expression
*(*(arr+s1)+s2)
is incorrect. The sub-expression *(arr+s1) has the type int. So the second use of the operator * produce a compilation error.
In the shown function there is emulated a two dimensional array using a pointer to a one-dimensional array. That is the one-dimensional array is logically split into chunks by length_column elements.
Here is a demonstrative program.
#include <stdio.h>
#define ROW_LENGTH 2
#define COLUMN_LENGTH 3
void display( const int *arr, size_t row_length, size_t column_length )
{
for ( size_t i = 0; i < row_length; i++ )
{
for ( size_t j = 0; j < column_length; j++ )
{
printf( "%d ", *( arr + i * column_length + j ) );
}
putchar( '\n' );
}
}
int main(void)
{
int arr[ROW_LENGTH * COLUMN_LENGTH] = { 1, 2, 3, 4, 5, 6 };
display( arr, ROW_LENGTH, COLUMN_LENGTH );
return 0;
}
Its output is
1 2 3
4 5 6