Passing multidimensional arrays as function arguments in C

In C can I pass a multidimensional array to a function as a single argument when I don't know what the dimensions of the array are going to be ?

In addition my multidimensional array may contain types other than strings.

From stackoverflow David

• Yes. Take a look at this page.

  From Jeremy Privett

• Simply put:

  An array is a pointer to a vector in memory. So, an array of arrays is a pointer to a pointer to a vector in memory.

  So:

  /**
  In a near Galaxy you have
  **/
  char a[100][100];
  giveMeTheAnswer( a ); 
  
  /**
  The event horizon must accept that multiverse
  **/
  void giveMeTheAnswer( char** pMatrix ) {
          pMatrix[0][0] = '4';
          pMatrix[0][1] = '2';
  };
  

  Johannes Schaub - litb : yeah that is totally wrong :) try pMatrix[1][0] = '4'; :)

  newacct : Wow that is so wrong. You completely confused arrays of arrays and arrays of pointers. They are completely different.

  John Bode : The type of pMatrix is `char (*)[100]` (pointer to 100-element array of char), not `char **`. Secondly, *arrays are not pointers*. Arrays and pointers are *different* objects that, in some contexts, can be used interchangeably.
  From ggasp

• You can do this with any data type. Simply make it a double pointer:

  typedef struct {
    int myint;
    char* mystring;
  } data;
  
  data** array;
  

  But don't forget you still have to malloc the variable, and it does get a bit complex:

  //initialize
  int x,y,w,h;
  w = 10; //width of array
  h = 20; //height of array
  
  //malloc the 'y' dimension
  array = malloc(sizeof(data*) * h);
  
  //iterate over 'y' dimension
  for(y=0;y<h;y++){
    //malloc the 'x' dimension
    array[y] = malloc(sizeof(data) * w);
  
    //iterate over the 'x' dimension
    for(x=0;x<w;x++){
      //malloc the string in the data structure
      array[y][x].mystring = malloc(sizeof(char) * 50); //50 chars
  
      //initialize
      array[y][x].myint = 6;
      array[y][x].mystring = "w00t";
    }
  }
  

  The code to deallocate the structure looks similar - don't forget to call free() on everything you malloced! (Also, in robust applications you should check the return of malloc().)

  Now let's say you want to pass this to a function. You can still use the double pointer, because you probably want to do manipulations on the data structure, not the pointer to pointers of data structures:

  int whatsMyInt(data** arrayPtr, int x, int y){
    return arrayPtr[y][x].myint;
  }
  

  Call this function with:

  printf("My int is %d.\n", whatsMyInt(array, 2, 4));
  

  Output:

  My int is 6.
  

  From superjoe30

• Pass an explicit pointer to the first element with the array dimensions as separate parameters. For example, to handle arbitrarily sized 2-d arrays of int:

  void func_2d(int *p, size_t M, size_t N)
  {
    size_t i, j;
    ...
    p[i*N+j] = ...;
  }
  

  which would be called as

  ...
  int arr1[10][20];
  int arr2[5][80];
  ...
  func_2d(&arr1[0][0], 10, 20);
  func_2d(&arr2[0][0], 5, 80);
  

  Same principle applies for higher-dimension arrays:

  func_3d(int *p, size_t X, size_t Y, size_t Z)
  {
    size_t i, j, k;
    ...
    p[i*Y+j*Z+k] = ...;
    ...
  }
  ...
  arr2[10][20][30];
  ...
  func_3d(&arr[0][0][0], 10, 20, 30);
  

  From John Bode