Defining and initialization of array using pointers

main()
{
    int **arr,x,y,i,j;
    x=5;
    y=2;
    arr = malloc ( x * sizeof(int*));
    for (i=0; i<x; i++)
    {
        *(arr+i) = (int*)malloc(y*sizeof(int));
    }
    for (i=0; i<x; i++)
    {
        for (j=0; j<y; j++)
        {
            printf ("\n%d", &arr[i][j]);
        }
    }
             
    getch();
             
} 

Original - C Code #include <stdio.h> #include <stdlib.h> int main() { int x = 5 ; int y = 2 ; int* memblock = malloc( x * y * sizeof(*memblock) ) ; int** arr = malloc ( x * sizeof(*arr) ) ; int i, j ; for( i = 0; i < x; i++ ) { arr[i] = &memblock[i * y] ; } for( i = 0; i < x; i++ ) { for( j = 0; j < y; j++ ) { printf( "\n%p", &arr[i][j] ) ; } } return 0 ; }

 
 
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
    int x = 5 ;
    int y = 2 ;
    int* memblock = malloc( x * y * sizeof(*memblock) ) ;
    int** arr = malloc ( x * sizeof(*arr) ) ;
    int i, j ;
 
    for( i = 0; i < x; i++ )
    {
        arr[i] = &memblock[i * y] ;
    }
 
    for( i = 0; i < x; i++ )
    {
        for( j = 0; j < y; j++ )
        {
            printf( "\n%p", &arr[i][j] ) ;
        }
    }
 
    return 0 ;
}
 

#include <stdio.h>
#include <stdlib.h>

#define ROWS 5
#define COLS 10

// Allocate arrays
// ---------------

// Allocate an array to store all the pointers to the rows,
// then allocate for each row.
int **allocPointerToPointer ( int rows, int cols ) {
  int r;
  int **result = malloc( rows * sizeof(*result) );
  for ( r = 0 ; r < rows ; r++ ) {
    result[r] = malloc( cols * sizeof(*result[r]) );
  }
  return result;
}

// Allocate an array to store all the pointers to the rows,
// then allocate for all the data in a single contiguous block
// Then loop to manually partition the data block for each row
// Use it in the same way as anything allocated with allocPointerToPointer
// but it needs a different free function.
int **allocPointerToPointerContiguous ( int rows, int cols ) {
  int **result = malloc(rows*sizeof(*result));
  int *data = malloc(rows*cols*sizeof(*data));
  int r;
  for ( r = 0 ; r < rows ; r++ ) {
    // note: the first row is also a pointer to the whole
    // block, which is used when it comes to freeing it.
    result[r] = data;
    data += rows;
  }
  return result;
}

// Allocate rows of [COLS] arrays
// Use this when the minor dimensions are a compile time constant.
int (*allocPointerToArray(int rows))[COLS] {
  int (*result)[COLS] = malloc( rows * sizeof(*result) );
  return result;
}


// Free arrays
// -----------
// These just match the previous mallocs.
void freePointerToPointer ( int **p, int rows ) {
  int r;
  for ( r = 0 ; r < rows ; r++ ) {
      free( p[r] );
  }
  free( p );
}
void freePointerToPointerContiguous ( int **p ) {
  free( p[0] );
  free( p );
}
void freePointerToArray ( int (*p)[COLS] ) {
  free( p );
}


// Initialise contents of arrays
// -----------------------------
// Notice how the loop construct is identical in all cases.
void initPointerToPointer ( int **p, int rows, int cols ) {
  int r,c;
  for ( r = 0 ; r < rows ; r++ ) {
    for ( c = 0 ; c < cols ; c++ ) {
      p[r][c] = r * c;
    }
  }
}
void initPointerToArray ( int (*p)[COLS], int rows ) {
  int r,c;
  for ( r = 0 ; r < rows ; r++ ) {
    for ( c = 0 ; c < COLS ; c++ ) {
      p[r][c] = r * c;
    }
  }
}


// Print contents
// --------------
// Notice how the loop construct is identical in all cases.
// Rather than [r][c], I've used pointer notation instead just for effect
void printPointerToPointer ( int **p, int rows, int cols ) {
  int r,c;
  int *q;
  for ( r = 0 ; r < rows ; r++, p++ ) {
    for ( c = 0, q = *p ; c < cols ; c++, q++ ) {
      printf("%2d ", *q);
    }
    printf("\n");
  }
  printf("\n");
}
void printPointerToArray ( int (*p)[COLS], int rows ) {
  int r,c;
  int *q;
  for ( r = 0 ; r < rows ; r++, p++ ) {
    for ( c = 0, q = *p ; c < COLS ; c++, q++ ) {
      printf("%2d ", *q);
    }
    printf("\n");
  }
  printf("\n");
}

int main(void)
{
  int a1[ROWS][COLS];
  int (*a2)[COLS] = allocPointerToArray(ROWS);
  int **a3 = allocPointerToPointer(ROWS,COLS);
  int **a4 = allocPointerToPointerContiguous(ROWS,COLS);
  
  initPointerToArray(a1,ROWS);
  initPointerToArray(a2,ROWS);
  initPointerToPointer(a3,ROWS,COLS);
  initPointerToPointer(a4,ROWS,COLS);
  
  printPointerToArray(a1,ROWS);
  printPointerToArray(a2,ROWS);
  printPointerToPointer(a3,ROWS,COLS);
  printPointerToPointer(a4,ROWS,COLS);
  
  // no need to free a1, it's just an array
  freePointerToArray(a2);
  freePointerToPointer(a3,ROWS);
  freePointerToPointerContiguous(a4);
  
  return 0;
}