C语言通过指针向函数传递多维数组 解决指针类型不兼容警告

问题现象 #

编写基于指针实现多维数组最大、最小值查找的程序时，编译器返回如下不兼容指针类型警告：

warning: passing argument 1 of 'MinMax' from incompatible pointer type [-Wincompatible-pointer-types]
   33 |     MinMax(V, ptm, ptM);
      |            ^
      |            |
      |            double (*)[5]

.\1-maxminarraymulti.c:18:22: note: expected 'double **' but argument is of type 'double (*)[5]'
   18 | void MinMax(double **V, double **mi, double **Ma);

原问题代码如下：

#include <stdio.h>

#define N 5
#define M 5

void MinMax(double **V, double **mi, double **Ma);

void main() {
    double V[N][M] = { { 1, 5, 2, 3, 9 },
                       { 12, 6, 90, 2, 0 },
                       { -12, 41, 2, 9, 56 },
                       { 78, 2, 1, 523, 39 }, 
                       { 92, 13, 63, 2, 12 } };

    double Min, Max;

    double *ptMin = &Min;
    double *ptMax = &Max;

    double **ptm = &ptMin;
    double **ptM = &ptMax;
    
    MinMax(V, ptm, ptM);
}

void MinMax(double **V, double **mi, double **Ma) {
    
    // 打印测试二维数组是否正确传递到函数内
    printf("%lf", V[3][0]);
}

报错核心逻辑为：MinMax函数形参V声明为double **类型，但传入的静态二维数组实参退化为double (*)[5]（指向长度为5的double数组的指针），二者内存布局不兼容，导致函数内无法正确访问二维数组元素。

根本原因 #

• 静态定义的二维数组是连续内存块，数组名传参时退化为指向第一行（长度为列数的一维数组）的指针，类型为double (*)[列数]，访问元素时的偏移计算是基于固定列长的
• double **是二级指针，指向的是一组double*指针，每个指针单独指向一行数据，这种结构通常用于动态分配的锯齿状二维数组，和静态二维数组的内存布局完全不同，二者不能直接隐式转换

修复方法 #

方法1：形参声明为匹配静态数组的数组指针类型（最简便，适配当前固定列数的场景） #

直接修改函数形参的类型，和实参退化后的类型匹配即可，修复后的完整可运行代码：

#include <stdio.h>

#define N 5
#define M 5

// 修改V的形参类型为指向长度为M的double数组的指针
void MinMax(double (*V)[M], double **mi, double **Ma);

int main() {
    double V[N][M] = { { 1, 5, 2, 3, 9 },
                       { 12, 6, 90, 2, 0 },
                       { -12, 41, 2, 9, 56 },
                       { 78, 2, 1, 523, 39 }, 
                       { 92, 13, 63, 2, 12 } };

    double Min, Max;

    double *ptMin = &Min;
    double *ptMax = &Max;

    double **ptm = &ptMin;
    double **ptM = &ptMax;
    
    MinMax(V, ptm, ptM);
    printf("Min: %.2lf, Max: %.2lf\n", Min, Max);
    return 0;
}

void MinMax(double (*V)[M], double **mi, double **Ma) {
    // 初始化最值为第一个元素
    **mi = V[0][0];
    **Ma = V[0][0];
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            if (V[i][j] < **mi) **mi = V[i][j];
            if (V[i][j] > **Ma) **Ma = V[i][j];
        }
    }
}

注：C语言中形参写为double V[][M]和double (*V)[M]完全等价，编译器会自动将数组形参调整为对应指针类型。

方法2：传入数组首地址+行列数，手动计算偏移（兼容任意列长的二维数组） #

如果需要适配不同列长的二维数组，可以把数组作为连续内存的首地址传入，通过行列下标手动计算元素位置：

#include <stdio.h>

#define N 5
#define M 5

// V改为指向连续内存首地址的一级指针，额外传入行列数
void MinMax(double *V, int rows, int cols, double **mi, double **Ma);

int main() {
    double V[N][M] = { { 1, 5, 2, 3, 9 },
                       { 12, 6, 90, 2, 0 },
                       { -12, 41, 2, 9, 56 },
                       { 78, 2, 1, 523, 39 }, 
                       { 92, 13, 63, 2, 12 } };

    double Min, Max;
    double *ptMin = &Min;
    double *ptMax = &Max;
    double **ptm = &ptMin;
    double **ptM = &ptMax;
    
    // 传入首地址、行数、列数
    MinMax(&V[0][0], N, M, ptm, ptM);
    printf("Min: %.2lf, Max: %.2lf\n", Min, Max);
    return 0;
}

void MinMax(double *V, int rows, int cols, double **mi, double **Ma) {
    **mi = V[0];
    **Ma = V[0];
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            double val = *(V + i * cols + j); // 手动计算元素偏移
            if (val < **mi) **mi = val;
            if (val > **Ma) **Ma = val;
        }
    }
}

注意事项 #

不要试图将二维数组强转为double**传入，这种写法会直接把连续存储的double数值解释为指针地址，触发内存访问越界，导致程序崩溃。

内容的提问来源于stack exchange，提问作者Marco Campanella