Übergeben von mehrdimensionalen Arrays als Funktionsargumente in C

  • Kann ich in C ein multidimensionales Array als einziges Argument an eine Funktion übergeben, wenn ich nicht weiß, wie die Dimensionen des Arrays aussehen werden?

    Außerdem kann mein mehrdimensionales Array andere Typen als Strings enthalten.

    07 August 2008
    David
4 answers
  • Übergeben Sie einen expliziten Zeiger an das erste Element mit den Array-Dimensionen als separate Parameter. Um beispielsweise willkürlich dimensionierte 2-d-Arrays von int zu handhaben:

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

    , die als

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

    Dasselbe Prinzip gilt für Arrays höherer Dimension:

     [pre> 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);
     
    26 May 2016
    John Bode
  • Sie können dies mit jedem Datentyp machen. Machen Sie es einfach zu einem Zeiger-zu-Zeiger:

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

    Aber vergessen Sie nicht, dass Sie das malloc nochmal malen müssen variabel, und es wird etwas komplexer:

     //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");
      }
    }
     

    Der Code, der die Struktur aufhebt, sieht ähnlich aus - don ' Vergessen Sie nicht, free () für alles, was Sie malloced haben, anzurufen! (In robusten Anwendungen sollten Sie außerdem die Rückgabe von malloc () prüfen) .)

    Nehmen wir an, Sie möchten dies an eine Funktion übergeben. Sie können den Doppelzeiger weiterhin verwenden, da Sie wahrscheinlich Änderungen an der Datenstruktur vornehmen möchten, nicht den Zeiger auf Zeiger von Datenstrukturen:

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

    Rufen Sie diese Funktion auf mit:

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

    Ausgabe:

     My int is 6.
     
    30 April 2015
    M.M
  • Sie können Ihre Funktion folgendermaßen definieren:

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

    Der Compiler führt dann alle Zeigerarithmetik aus für Sie.

    Beachten Sie, dass die Bemaßungsgrößen vor dem Array selbst angezeigt werden müssen.

    GNU C ermöglicht die Weiterleitung von Argumenten (falls Sie wirklich Dimensionen nach dem Array übergeben müssen):

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

    Der erste dimension kann zwar auch als Argument übergeben werden, ist jedoch für den C-Compiler unbrauchbar (selbst für sizeof -Operatoren, die auf ein als Argument übergebenes Array angewendet werden, wird die Behandlung immer als Zeiger auf das erste Element behandeln).

    12 January 2015
    rslemos
  •  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
    }
     
    07 February 2016
    Markus SafarMHop