web-dev-qa-db-fra.com

Comment passer un tableau 2D (matrice) dans une fonction en C?

Je dois faire cela pour continuer les opérations sur la matrice. Cela signifie-t-il qu'il doit être passé par référence?

Cela suffira-t-il?

void operate_on_matrix(char matrix[][20]);

cmultidimensional-arrayparameter-passing
44
Shweta

C n’a pas vraiment de tableaux multidimensionnels, mais il existe plusieurs façons de les simuler. La manière de passer de tels tableaux à une fonction dépend de la manière utilisée pour simuler les multiples dimensions:

1) Utilisez un tableau de tableaux. Cela ne peut être utilisé que si les limites de votre tableau sont entièrement déterminées lors de la compilation, ou si votre compilateur supporte VLA's :

#define ROWS 4
#define COLS 5

void func(int array[ROWS][COLS])
{
  int i, j;

  for (i=0; i<ROWS; i++)
  {
    for (j=0; j<COLS; j++)
    {
      array[i][j] = i*j;
    }
  }
}

void func_vla(int rows, int cols, int array[rows][cols])
{
  int i, j;

  for (i=0; i<rows; i++)
  {
    for (j=0; j<cols; j++)
    {
      array[i][j] = i*j;
    }
  }
}

int main()
{
  int x[ROWS][COLS];

  func(x);
  func_vla(ROWS, COLS, x);
}

2) Utilisez un tableau (alloué dynamiquement) de pointeurs vers des tableaux (alloués dynamiquement). Ceci est principalement utilisé lorsque les limites du tableau ne sont pas connues jusqu'au moment de l'exécution.

void func(int** array, int rows, int cols)
{
  int i, j;

  for (i=0; i<rows; i++)
  {
    for (j=0; j<cols; j++)
    {
      array[i][j] = i*j;
    }
  }
}

int main()
{
  int rows, cols, i;
  int **x;

  /* obtain values for rows & cols */

  /* allocate the array */
  x = malloc(rows * sizeof *x);
  for (i=0; i<rows; i++)
  {
    x[i] = malloc(cols * sizeof *x[i]);
  }

  /* use the array */
  func(x, rows, cols);

  /* deallocate the array */
  for (i=0; i<rows; i++)
  {
    free(x[i]);
  }
  free(x);
}

3) Utilisez un tableau à 1 dimension et corrigez les index. Cela peut être utilisé à la fois avec des tableaux alloués de manière statique (taille fixe) et alloués de manière dynamique:

void func(int* array, int rows, int cols)
{
  int i, j;

  for (i=0; i<rows; i++)
  {
    for (j=0; j<cols; j++)
    {
      array[i*cols+j]=i*j;
    }
  }
}

int main()
{
  int rows, cols;
  int *x;

  /* obtain values for rows & cols */

  /* allocate the array */
  x = malloc(rows * cols * sizeof *x);

  /* use the array */
  func(x, rows, cols);

  /* deallocate the array */
  free(x);
}

4) Utilisez un VLA alloué dynamiquement. L’un des avantages de cette option 2 est qu’il n’ya qu’une seule allocation de mémoire; une autre est que moins de mémoire est nécessaire car le tableau de pointeurs n'est pas requis.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

extern void func_vla(int rows, int cols, int array[rows][cols]);
extern void get_rows_cols(int *rows, int *cols);
extern void dump_array(const char *tag, int rows, int cols, int array[rows][cols]);

void func_vla(int rows, int cols, int array[rows][cols])
{
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            array[i][j] = (i + 1) * (j + 1);
        }
    }
}

int main(void)
{
    int rows, cols;

    get_rows_cols(&rows, &cols);

    int (*array)[cols] = malloc(rows * cols * sizeof(array[0][0]));
    /* error check omitted */

    func_vla(rows, cols, array);
    dump_array("After initialization", rows, cols, array);

    free(array);
    return 0;
}

void dump_array(const char *tag, int rows, int cols, int array[rows][cols])
{
    printf("%s (%dx%d):\n", tag, rows, cols);
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
            printf("%4d", array[i][j]);
        putchar('\n');
    }
}

void get_rows_cols(int *rows, int *cols)
{
    srand(time(0));           // Only acceptable because it is called once
    *rows = 5 + Rand() % 10;
    *cols = 3 + Rand() % 12;
}

(Voir srand() - pourquoi l’appeler une seule fois? .)

86
Bart van Ingen Schenau

Je ne sais pas ce que vous entendez par "les données ne sont pas perdues". Voici comment passer un tableau 2D normal à une fonction:

void myfunc(int arr[M][N]) { // M is optional, but N is required
  ..
}

int main() {
  int somearr[M][N];
  ...
  myfunc(somearr);
  ...
}
10
casablanca

Manière la plus simple: passer un tableau 2D de longueur variable

La technique la plus propre pour C & C++ est la suivante: passer un tableau 2D comme un tableau 1D, puis l’utiliser en tant que 2D dans la fonction.

void func(int row, int col, int* matrix){
    int i, j;
    for(i=0; i<row; i++){
        for(j=0; j<col; j++){
            printf("%d ", *(matrix + i*col + j)); // or better: printf("%d ", *matrix++);
        }
        printf("\n");
    }
}

int main(){
    int matrix[2][3] = { {1, 2, 3}, {7, 8, 9} };
    func(2, 3, matrix[0]);

    return 0;
}
2
Minhas Kamal

Tableau 2D:

int sum(int array[][COLS], int rows)
{

}

Tableau 3D:

int sum(int array[][B][C], int A)
{

}

Tableau 4D:

int sum(int array[][B][C][D], int A)
{

}

et tableau nD:

int sum(int ar[][B][C][D][E][F].....[N], int A)
{

}
0
shinxg