Passing multidimensional arrays as function arguments in C


Translate

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.


Alle Antworten
  • Translate

    You can do this with any data type. Simply make it a pointer-to-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(50); //50 chars
    
        //initialize
        array[y][x].myint = 6;
        strcpy(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.
    

  • Translate

    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*Z+j*Z+k] = ...;
      ...
    }
    ...
    arr2[10][20][30];
    ...
    func_3d(&arr[0][0][0], 10, 20, 30);
    

  • Translate

    You can declare your function as:

    f(int size, int data[][size]) {...}
    

    The compiler will then do all pointer arithmetic for you.

    Note that the dimensions sizes must appear before the array itself.

    GNU C allows for argument declaration forwarding (in case you really need to pass dimensions after the array):

    f(int size; int data[][size], int size) {...}
    

    The first dimension, although you can pass as argument too, is useless for the C compiler (even for sizeof operator, when applied over array passed as argument will always treat is as a pointer to first element).


  • Translate
    int matmax(int **p, int dim) // p- matrix , dim- dimension of the matrix 
    {
        return p[0][0];  
    }
    
    int main()
    {
       int *u[5]; // will be a 5x5 matrix
    
       for(int i = 0; i < 5; i++)
           u[i] = new int[5];
    
       u[0][0] = 1; // initialize u[0][0] - not mandatory
    
       // put data in u[][]
    
       printf("%d", matmax(u, 0)); //call to function
       getche(); // just to see the result
    }