C – passer un tableau 2d comme argument de fonction?

On peut facilement définir une fonction qui accepte un argument de 1d array comme ceci:

 int MyFunction( const float arr[] ) { // do something here, then return... return 1 } 

Bien qu’une définition telle que: int MyFunction( const float* arr ) puisse également fonctionner.

Comment définir une fonction qui accepte un argument de 2d array 2D?

Je sais que cela fonctionne: int MyFunction( const float** arr ) – mais est-il possible d’utiliser la première variante qui utilise [] ?

En C99, vous pouvez fournir les dimensions du tableau avant de le transmettre:

  void array_function(int m, int n, float a[m][n]) { for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) a[i][j] = 0.0; } void another_function(void) { float a1[10][20]; float a2[15][15]; array_function(10, 20, a1); array_function(15, 15, a2); } 

Essayez quelque chose comme ça:

 int MyFunction(size_t ncols, const float arr[][ncols]) { // ... } 

lorsque nous transmettons un tableau 2D en tant qu’argument aux fonctions, il est facultatif de spécifier les dimensions les plus à gauche. Le point clé ici est le point lorsque toutes les modifications apscopes aux fonctions qui se modifient sont reflétées dans les fonctions appelantes. recevoir un pointeur sur un tableau 1D. Et la taille de cela est le nombre de colonnes. exemples

1 – int funct(int (*a) [4]);

ici a est un pointeur sur un tableau d’entier. nous pouvons simplement passer comme ça aussi

2- void funct(int a[][4]);

comme je l’ai dit plus tôt, la plupart des côtés sont toujours optionnels. Dans le premier exemple, la taille d’un sera 4 parce que c’est normalement juste un pointeur. alors que la taille de * a sera 16 car nous avons 4 colonnes et pour chaque colonne nous avons 4 octets donc 4 * 4 = 16 octets.

Mais la méthode la plus préférable consiste à toujours utiliser des allocations de mémoire dynamics.

J’espère que tu es clair

La méthode la plus simple serait de passer le premier élément et d’effectuer les calculs de tableau manuellement.

Cet exemple longish utilise une macro pour extraire de manière semi-automatique les dimensions du tableau à utiliser dans l’appel.

 struct font { int disp, sortingg; }; struct font font3[3][3]; #define dim(x) (sizeof(x)/sizeof*(x)) #define font_and_dims(x) (struct font *)x, dim(x), dim(*x) int print(char *s, struct font *font, int dimy, int dimx) { ... } main(){ ... print(*av, font_and_dims(font3)); ... } 

La fonction appelée accède au tableau à la dure.

 print(){ ... font[row*dimx+col] ... } 

N’ayez pas peur de faire défiler l’écran: les bonnes choses sont en bas! Cette fonction pédante laide au sumt offre une portabilité ultime du jeu de caractères; mais c’est une horreur, je l’avoue.

 #include  #include  int ao(int c) { switch(c) { case '0':return 0; case '1':return 1; case '2':return 2; case '3':return 3; case '4':return 4; case '5':return 5; case '6':return 6; case '7':return 7; case '8':return 8; case '9':return 9; case 'A':case 'a':return 10; case 'B':case 'b':return 11; case 'C':case 'c':return 12; case 'D':case 'd':return 13; case 'E':case 'e':return 14; case 'F':case 'f':return 15; default:return -1; } } enum { A = 1 << 0, B = 1 << 1, C = 1 << 2, D = 1 << 3, E = 1 << 4, F = 1 << 5, G = 1 << 6, H = 1 << 7 }; int seg[] = { /*0*/ A|B|C|D|E|F, /*1*/ B|C, /*2*/ A|B| D|E| G, /*3*/ A|B|C|D| G, /*4*/ B|C| F|G, /*5*/ A| C|D| F|G, /*6*/ A| C|D|E|F|G, /*7*/ A|B|C, /*8*/ A|B|C|D|E|F|G, /*9*/ A|B|C| F|G, /*A*/ A|B|C|D|E| G, /*A|B|C| E|F|G,*/ /*b*/ C|D|E|F|G, /*C*/ D|E| G, /*A| D|E|F,*/ /*d*/ B|C|D|E| G, /*E*/ A|B| D|E|F|G, /*A| D|E|F|G,*/ /*F*/ A| E|F|G, }; struct font { int disp, trig; }; /* _ |_| |_| */ struct font font3[3][3] = { { { 0,0}, {'_',A}, { 0,0} }, { {'|',F}, {'_',G}, {'|',B} }, { {'|',E}, {'_',D}, {'|',C} }, }; /* ___ | | |___| | | |___| */ struct font font5[5][5] = { { { 0,0}, {'_',A}, {'_',A}, {'_',A}, { 0,0} }, { {'|',F}, { 0,0}, { 0,0}, { 0,0}, {'|',B} }, { {'|',F}, {'_',G}, {'_',G}, {'_',G}, {'|',B} }, { {'|',E}, { 0,0}, { 0,0}, { 0,0}, {'|',C} }, { {'|',E}, {'_',D}, {'_',D}, {'_',D}, {'|',C} } }; /* ____ | | | | | | |____| | | | | | | |____| */ struct font font9[9][7] = { { { 0,0}, {'_',A}, {'_',A}, {'_',A}, {'_',A}, { 0,0}, {0,0} }, { {'|',F}, { 0,0}, { 0,0}, { 0,0}, { 0,0}, {'|',B}, {0,0} }, { {'|',F}, { 0,0}, { 0,0}, { 0,0}, { 0,0}, {'|',B}, {0,0} }, { {'|',F}, { 0,0}, { 0,0}, { 0,0}, { 0,0}, {'|',B}, {0,0} }, { {'|',F}, {'_',G}, {'_',G}, {'_',G}, {'_',G}, {'|',B}, {0,0} }, { {'|',E}, { 0,0}, { 0,0}, { 0,0}, { 0,0}, {'|',C}, {0,0} }, { {'|',E}, { 0,0}, { 0,0}, { 0,0}, { 0,0}, {'|',C}, {0,0} }, { {'|',E}, { 0,0}, { 0,0}, { 0,0}, { 0,0}, {'|',C}, {0,0} }, { {'|',E}, {'_',D}, {'_',D}, {'_',D}, {'_',D}, {'|',C}, {0,0} }, }; #define dim(x) (sizeof(x)/sizeof*(x)) #define font_and_dims(x) (struct font *)x, dim(x), dim(*x) int print(char *s, struct font *font, int dimy, int dimx) { int row, col; char *sp; for (row = 0; row < dimy; row++) { for (sp = s; *sp; sp++) { for (col = 0; col < dimx; col++) { putchar( seg[ao(*sp)] & font[row*dimx+col].trig ? font[row*dimx+col].disp : ' '); } } putchar('\n'); } } int main(int ac, char **av) { enum { F1, F2, F3 } fz = F1; for (++av,--ac;ac;ac--,av++) { if (av[0][0] == '-') { switch (av[0][1]) { case '1': fz=F1; continue; case '2': fz=F2; continue; case '3': fz=F3; continue; default: fprintf(stderr, "Unrecognized Option!\n"); } } if (strspn(*av, "0123456789abcdefABCDEF") != strlen(*av)) fprintf(stderr, "Hex only!\n"); else switch(fz) { case F1: print(*av, font_and_dims(font3)); break; case F2: print(*av, font_and_dims(font5)); break; case F3: print(*av, font_and_dims(font9)); break; default: fprintf(stderr, "Invalid Font!\n"); } } return 0; } 

En C89, vous pouvez utiliser

 typedef float OneRow[2]; void func(OneRow *arr) { printf("%f",arr[1][0]); } ... OneRow arr[] = {{1,2},{3,4},{5,6}}; func(arr); ...