如何在C中的函数中传递二维数组(矩阵)？

Question

如何在C中的函数中传递二维数组(矩阵)？我需要这样做来保持矩阵上的操作。这是否意味着它需要以参考的方式通过？这样就够了吗？void operate_on_matrix(char matrix[][20]);

Answer 1

C实际上没有多维数组，但是有几种方法来模拟它们.将这些数组传递给函数的方式取决于用于模拟多维的方式：

1)使用数组。这只能在您的数组边界在编译时完全确定或编译器支持的情况下才能使用。VLA‘s:

#define ROWS 4#define COLS 5void 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)使用指向(动态分配)数组的指针数组。这主要是在运行时才知道数组边界时使用的。

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)使用一维数组，并固定索引。这可以用于静态分配(固定大小)和动态分配的数组：

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)使用动态分配的VLA。与选项2相比，它的一个优点是只有一个内存分配；另一个优点是不需要指针数组，因此需要更少的内存。

#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;}

(见srand()-为什么只叫一次？.)

Answer 2

我不知道你所说的“数据不会丢失”是什么意思。下面是如何将普通的2D数组传递给函数：

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

Answer 3

最简单的方法：传递可变长度的二维阵列

_{C&C+最简洁的技术是：像一维数组一样传递2D数组，然后在函数内部作为2D使用。}

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