Übergeben mehrdimensionaler Arrays als Funktionsargumente in C

Im C kann ich Übergeben Sie ein mehrdimensionales Array zu einer Funktion als einziges Argument wenn ich nicht weiß, was die Dimensionen des Arrays sein werden?

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

Übergeben Sie einen expliziten Zeiger auf das erste Element mit den Array-Dimensionen als separate Parameter. Zum Beispiel, um beliebig große 2-D-Arrays von int zu verarbeiten:

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

was als bezeichnet werden würde

...
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 höherdimensionale 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);

Sie können Ihre Funktion wie folgt deklarieren:

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

Der Compiler erledigt dann die gesamte Zeigerarithmetik für Sie.

Beachten Sie, dass die Bemaßungsgrößen erscheinen müssen Vor das Array selbst.

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

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

Obwohl Sie die erste Dimension auch als Argument übergeben können, ist sie für den C-Compiler nutzlos (selbst für den sizeof-Operator, wenn er auf ein als Argument übergebenes Array angewendet wird, wird es immer als Zeiger auf das erste Element behandelt).

Sie können dies mit jedem Datentyp tun. Machen Sie es einfach zu einem Zeiger-zu-Zeiger:

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

data** array;

Aber vergessen Sie nicht, dass Sie die Variable immer noch mallocieren müssen, und es wird ein bisschen komplex:

//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 zum Freigeben der Struktur sieht ähnlich aus – vergessen Sie nicht, free() für alles aufzurufen, was Sie mallociert haben! (Auch in robusten Anwendungen sollten Sie Überprüfen Sie die Rückgabe von malloc().)

Nehmen wir nun an, Sie möchten dies an eine Funktion übergeben. Sie können immer noch den Doppelzeiger verwenden, da Sie wahrscheinlich Manipulationen an der Datenstruktur vornehmen möchten, nicht am 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.

Kann ich in C ein mehrdimensionales Array als einzelnes Argument an eine Funktion übergeben, wenn ich nicht weiß, welche Dimensionen das Array haben wird?

Nein

Wenn Sie mit “einzelnem Argument” meinen, nur das Array zu übergeben, ohne die Array-Dimensionen zu übergeben, nein, das können Sie nicht. Zumindest nicht für echte mehrdimensionale Arrays.

Sie können die Dimension setzen[s] in eine Struktur zusammen mit dem Array und behaupten, dass Sie ein “einzelnes Argument” übergeben, aber das ist wirklich nur das Packen mehrerer Werte in einen einzigen Container und das Aufrufen dieses Containers “ein Argument”.

Sie können ein Array mit bekanntem Typ und bekannter Anzahl von Dimensionen, aber unbekannter Größe übergeben, indem Sie die Dimensionen selbst und das Array wie folgt übergeben:

void print2dIntArray( size_t x, size_t y, int array[ x ][ y ] )
{
    for ( size_t ii = 0, ii < x; ii++ )
    {
        char *sep = "";
        for ( size_t jj = 0; jj < y; jj++ )
        {
            printf( "%s%d", sep, array[ ii ][ jj ] );
            sep = ", ";
        }
        printf( "\n" );
    }
}

Sie würden diese Funktion wie folgt aufrufen:

int a[ 4 ][ 5 ];
int b[ 255 ][ 16 ];

...

print2dIntArray( 4, 5, a );

....

printt2dIntArray( 255, 16, b );

In ähnlicher Weise kann ein dreidimensionales Array von beispielsweise a struct pixel:

void print3dPixelArray( size_t x, size_t y, size_t z, struct pixel pixelArray[ x ][ y ][ z ] )
{
    ...
}

oder ein 1-dimensional double Array:

void print1dDoubleArray( size_t x, double doubleArray[ x ] )
{
    ...
}

ABER…

Es kann jedoch möglich sein, “Arrays von Zeigern an Arrays von Zeigern auf … ein Array des Typs zu übergeben X” Konstrukte, die oft fälschlicherweise als “mehrdimensionales Array” als einzelnes Argument bezeichnet werden, solange der Basistyp X hat einen Sentinel-Wert, der verwendet werden kann, um das Ende des letzten eindimensionalen Arrays des Typs auf der niedrigsten Ebene anzuzeigen X.

Zum Beispiel die char **argv Wert übergeben main() ist ein Zeiger auf ein Array von Zeigern auf char. Das anfängliche Array von char * Zeiger enden mit a NULL Sentinel-Wert, während jeder char Array, auf das durch das Array von verwiesen wird char * Zeiger enden mit a NUL Zeichenwert von '\0'.

Zum Beispiel, wenn Sie verwenden können NAN als Sentinel-Wert, da die tatsächlichen Daten dies nicht tun je sei ein NANkönnten Sie a drucken double ** so was:

void printDoubles( double **notAnArray )
{
    while ( *notAnArray )
    {
        char *sep = "";
        for ( size_t ii = 0;  ( *notAnArray )[ ii ] != NAN; ii++ )
        {
            printf( "%s%f", sep, ( *notAnArray )[ ii ] );
            sep = ", ";
        }

        notAnArray++;
    }
}

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
}