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[0], 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;
}