如何将二维数组传递给C中的函数？

Question

我的函数原型是

int** rotate(int **arr, int row, int col, int fl);

其中arr是二维数组，row和col分别是2D数组的行数和列数，fl是一个标志变量。如果fl的值是0，则数组将向右旋转，如果fl是1，则数组将向左旋转。

我把这个函数调用如下：

int **res= rotate(arr, row, col, fl);

但我得到了一个警告和一个注释

[Warning] passing argument 1 of 'rotate' from incompatible pointer type.

[Note] expected 'int **' but argument is of type 'int (*)[20]' 

Answer 1

指向指针的指针与指向数组的指针不同。数组到指针的衰减只能发生在最左侧（例如int [3][20]到int (*)[20]）。

将您的函数声明更改为

int** rotate(int (*arr)[20], int row, int col, int fl);

或者更明显的是，

int** rotate(int arr[][20], int row, int col, int fl);

请注意，您必须在编译时修复大小。

Answer 2

如果您的编译器支持可变长度数组，那么函数声明可以采用以下方式

void rotate( size_t row, size_t col, int arr[][col], int fl);

要么

void rotate( size_t row, size_t col, int arr[][col], _Bool fl);

在这种情况下，您可以使用不同大小的数组。

这是一个示范计划

#include <stdio.h>

void rotate( size_t row, size_t col, int a[][col], _Bool fl )
{
    for ( size_t i = 0; i < ( fl ? row : col ); i++ )
    {
        for ( size_t j = 0; j < ( fl ? col : row ); j++ )
        {
            printf( "%d ", a[fl ? i : j][fl ? j : i] );
        }
        putchar( '\n' );
    }
}

#define N1  3

int main(void) 
{
    int a[][3] =
    {
        { 1, 2, 3 },
        { 4, 5, 6 }
    };

    rotate( sizeof( a ) / sizeof( *a ), N1, a, 0 );
    putchar( '\n' );

    rotate( sizeof( a ) / sizeof( *a ), N1, a, 1 );
    putchar( '\n' );

    return 0;
}

它的输出是

1 4 
2 5 
3 6 

1 2 3 
4 5 6 

否则，如果您要在函数中创建新数组，则该函数可以看起来如下面的演示程序中所示。

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

int ** rotate( size_t, size_t, int a[][*], _Bool fl );

int ** rotate( size_t row, size_t col, int a[][col], _Bool fl )
{
    int **p = malloc( col * sizeof( int * ) );
    for ( size_t i = 0; i < col; i++ )
    {
        p[i] = ( int * )malloc( row * sizeof( int ) );
    }

    if ( fl )
    {
        for ( size_t i = 0; i < row; i++ )
        {
            for ( size_t j = 0; j < col; j++ )
            {
                p[col - j - 1][i] = a[i][j];
            }
        }
    }
    else
    {
        for ( size_t i = 0; i < row; i++ )
        {
            for ( size_t j = 0; j < col; j++ )
            {
                p[j][i] = a[row - i - 1][j];
            }
        }
    }

    return p;
}

#define M   2
#define N   3

int main(void) 
{
    int a[M][N] =
    {
        { 1, 2, 3 },
        { 4, 5, 6 }
    };

    int **p = rotate( M, N, a, 0 );

    for ( size_t i = 0; i < N; i++ )
    {
        for ( size_t j = 0; j < M; j++ )
        {
            printf( "%d ", p[i][j] );
        }
        putchar( '\n' );
    }
    putchar( '\n' );

    for ( size_t i = 0; i < N; i++ )
    {
        free( p[i] );
    }
    free( p );

    p = rotate( M, N, a, 1 );

    for ( size_t i = 0; i < N; i++ )
    {
        for ( size_t j = 0; j < M; j++ )
        {
            printf( "%d ", p[i][j] );
        }
        putchar( '\n' );
    }
    putchar( '\n' );

    for ( size_t i = 0; i < N; i++ )
    {
        free( p[i] );
    }
    free( p );

    return 0;
}

它的输出是

4 1 
5 2 
6 3 

3 6 
2 5 
1 4 

Answer 3

从示例中，我假设您使用的是arr的静态定义。

指针指针与2D数组不同。

更改

int** rotate(int **arr, int row, int col, int fl);

至

int** rotate(int arr[][20], int row, int col, int fl);

请注意，必须在编译之前定义no列。