Übergeben von mehrdimensionalen Arrays als Funktionsargumente in C

Question

In C kann ich ein multidimensionales Array als einzelnes Argument an eine Funktion übergeben, wenn ich nicht weiß, wie die Dimensionen des Arrays sein werden?

Zusätzlich kann mein mehrdimensionales Array andere Typen als Strings enthalten.

Answer 1

Sie können dies mit jedem Datentyp tun. machen es einfach einen Zeiger auf Zeiger:

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

data** array; 

Aber nicht vergessen, dass Sie immer noch die Variable malloc haben, und es hat ein wenig 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 ausplanen die Struktur sieht ähnlich aus - vergessen Sie nicht, kostenlos() auf alles, was Sie malloced! (Auch in robusten Anwendungen sollten Sie check the return of malloc().)

Jetzt sagen wir, Sie möchten dies an eine Funktion übergeben. Sie können immer noch den doppelten Zeiger verwenden, weil Sie wahrscheinlich Manipulationen an der Datenstruktur tun wollen, nicht den Zeiger auf Zeiger von Datenstrukturen:

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

Rufen Sie diese Funktion mit:

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

Ausgang:

My int is 6. 

Answer 2

Übergeben Sie einen expliziten Zeiger auf das erste Element mit den Array-Dimensionen als separate Parameter. Beispielsweise Größe 2-D-Arrays von int zu hand willkürlich:

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); 

Gleiches Prinzip für höherdimensionale Arrays gilt aufgerufen werden würde:

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); 

Answer 3

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 
} 

Answer 4

Sie können Ihre Funktion wie folgt deklarieren:

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

Der Compiler wird dann alle Zeigerarithmetik für Sie tun.

Beachten Sie, dass die Größengrößen vor das Array selbst angezeigt werden müssen.

GNU C Argument Erklärung Weiterleitung erlaubt (falls Sie wirklich brauchen Dimensionen nach dem Array übergeben):

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

Die erste Dimension, obwohl man auch als Argument übergeben kann, ist nutzlos für die C-Compiler (selbst für den Operator sizeof, wenn es über ein Array angewendet wird, das als Argument übergeben wird, wird es immer als ein Zeiger auf das erste Element behandelt).