1. ## Graphic explanation Bidimensinal arrays pointers and addresses

Hello

I am building on a code snippet I posted before. I m trying to see how the memory addresses are for pointers themselves and for those where they point to.

I am using a bidimensional array, so, pointer to pointer stuff. Therefore, if I get it right, the addresses the row pointers Point To should match the addresses the column pointers are Located At.

A bidimensional array is an array that has arrays as elements, in other words, pointers which point to the address memory where the array (of columns) start &myarray, which is in turn comprised of pointers.

Here below (x) is a pointer to an array (a row) which contains pointers to another addresses, (the columns here)

each row has a different (x) that points to a different address, but the pointers of each row have the same values because all point to the same columns?

The ^ are different memory addresses corresponding to columns.
Within a row they are different, but they repeat themselves for every row ?

^ ^ ^
x __| ___|__| ROW 1;

^ ^ ^
x __| ___|__| ROW 2

etc
Code:
```#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()  {

int **mat; // Pointer to pointer
int rows, cols, i, j, k, x, y;

printf("Number of Rows: ");
scanf("%d", &rows);

mat = (int **)malloc(rows*sizeof(int*));
// array of number of rows, each row containing pointers to columns, that is why it is a pointer to pointer, however and of course
// each row has the pointers pointing to the same memory addresses
// as they all point to same columns as other rows

for(x = 0; x < rows; x ++)
{
printf("The pointer %d points to %p and itself is located at %p\n\n: ", x, mat[x], &mat[x]);

}

printf("Number of Cols: ");
scanf("%d", &cols);
fflush(stdin);

for (i=0; i<rows; i++)  // for each row ...
{
mat[i] = (int *)malloc (cols * sizeof(int)); // add these many cols
}

for (j = 0; j<rows; j ++)
{

for (k = 0; k<cols; k++)
{

mat[j][k] = j * k;

printf("Array[%d][%d]  %p and stores a value of %d\n: ", j, k,  &mat[j][k], *(*(mat+j)+k));
}

}

getchar();

}```
============================= UPDATE ================================================== =================

I have found another snippet which clarifies this better. I have modified it slightly to show it clearer
Code:
```#include <stdio.h>
#include <stdlib.h>

int main(void)
{
int **rptr;
int *aptr;
int *testptr;
int k;
int nrows = 5;     /* Both nrows and ncols could be evaluated */
int ncols = 8;    /* or read in at run time */
int row, col;

/* we now allocate the memory for the array */

aptr = malloc(nrows * ncols * sizeof(int));

printf("la direccion de este array en (0,0) es %p\n\n: ", &aptr);

if (aptr == NULL)
{
puts("\nFailure to allocate room for the array");
exit(0);
}

/* next we allocate room for the pointers to the rows */

rptr = malloc(nrows * sizeof(int *));

printf("la direccion de este bloque de los pointers para las rows es) %p\n\n: ", &rptr);

if (rptr == NULL)
{
puts("\nFailure to allocate room for pointers");
exit(0);
}

/* and now we 'point' the pointers */

for (k = 0; k < nrows; k++)
{
rptr[k] = aptr + (k * ncols);
}

/* Now we illustrate how the row pointers are incremented */
printf("\n\nIllustrating how row pointers are incremented");
printf("\n\nIndex   Pointer(hex)  Diff.(dec)");

for (row = 0; row < nrows; row++)
{
printf("\n%d         %p", row, rptr[row]);
if (row > 0)
printf("              %d",(rptr[row] - rptr[row-1]));
}
printf("\n\nAnd now we print out the array\n");
for (row = 0; row < nrows; row++)
{
for (col = 0; col < ncols; col++)
{
rptr[row][col] = row + col;
printf("%d ", rptr[row][col]);
}
putchar('\n');
}

puts("\n");

/* and here we illustrate that we are, in fact, dealing with
a 2 dimensional array in a contiguous block of memory. */
printf("And now we demonstrate that they are contiguous in memory\n");

testptr = aptr;
for (row = 0; row < nrows; row++)
{
for (col = 0; col < ncols; col++)
{
printf("%d %p ", *(testptr++), &testptr[row]);

}
putchar('\n');
}

getchar();

return 0;
}``` Popular pages Recent additions addresses, bidimensional arrays, pointers 