C 将2d指针数组传递给函数时出错

所以我要传递一个3乘3的浮点数组。函数foo将为每个指针分配内存。这是代码

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

void foo(float ***A);

int main(int argc, char **argv) {
    float* A[3][3];
    foo(&A);
}

void foo(float ***A) {
   int i,j;
   for(i=0;i<3;i++){
      for(j=0;j<3;j++){
        A[i][j] = malloc(2*sizeof(float));
        A[i][j][0] = 21;
      }
   }
}

因此，如果我调用foo（A）而不是foo（&A），则会出现以下错误：

C:\Users\tony\Code\MPI>gcc test.c
test.c: In function 'main':
test.c:8: warning: passing argument 1 of 'foo' from incompatible pointer type
test.c:4: note: expected 'float ***' but argument is of type 'float * (*)[3]'

---

如果要将二维数组传递给函数：

int labels[NROWS][NCOLUMNS];
f(labels);

函数的声明必须匹配：

void f(int labels[][NCOLUMNS])
{ ... }

或

---

如果要将二维数组传递给函数：

int labels[NROWS][NCOLUMNS];
f(labels);

函数的声明必须匹配：

void f(int labels[][NCOLUMNS])
{ ... }

或

---

如果要将二维数组传递给函数：

int labels[NROWS][NCOLUMNS];
f(labels);

函数的声明必须匹配：

void f(int labels[][NCOLUMNS])
{ ... }

或

---

如果要将二维数组传递给函数：

int labels[NROWS][NCOLUMNS];
f(labels);

函数的声明必须匹配：

void f(int labels[][NCOLUMNS])
{ ... }

或

---

float*A[3][3]是指针的2D数组

但您正在传递一个的地址，并将其作为
float***
接收。这就是错误所在

将其作为
foo（A）传递并将功能原型更改为

void foo(float* A[][3]);

另外，
typeof
应该是
sizeof

A[i][j] = malloc(2*sizeof(float));

float*A[3][3]是指针的2D数组

但您正在传递一个的地址，并将其作为
float***
接收。这就是错误所在

将其作为
foo（A）传递并将功能原型更改为

void foo(float* A[][3]);

另外，
typeof
应该是
sizeof

A[i][j] = malloc(2*sizeof(float));

float*A[3][3]是指针的2D数组

但您正在传递一个的地址，并将其作为
float***
接收。这就是错误所在

将其作为
foo（A）传递并将功能原型更改为

void foo(float* A[][3]);

另外，
typeof
应该是
sizeof

A[i][j] = malloc(2*sizeof(float));

float*A[3][3]是指针的2D数组

但您正在传递一个的地址，并将其作为
float***
接收。这就是错误所在

将其作为
foo（A）传递并将功能原型更改为

void foo(float* A[][3]);

另外，
typeof
应该是
sizeof

A[i][j] = malloc(2*sizeof(float));

你可以试试这个：

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

void foo(float *(*A)[3][3]);

int main(int argc, char **argv) {
    float* A[3][3];
    foo(&A);
    return 0;
}

void foo(float *(*A)[3][3]) {
    int i,j;
    for(i=0;i<3;i++){
        for(j=0;j<3;j++){
            (*A)[i][j] = malloc(2*sizeof(float));
            (*A)[i][j][0] = 21;
        }
    }
}

#包括
#包括
无效foo（浮动*（*A）[3][3]）；
int main（int argc，字符**argv）{
浮动*A[3][3]；
foo&A；
返回0；
}
无效foo（浮动*（*A）[3][3]）{
int i，j；
对于（i=0；i你可以试试这个：

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

void foo(float *(*A)[3][3]);

int main(int argc, char **argv) {
    float* A[3][3];
    foo(&A);
    return 0;
}

void foo(float *(*A)[3][3]) {
    int i,j;
    for(i=0;i<3;i++){
        for(j=0;j<3;j++){
            (*A)[i][j] = malloc(2*sizeof(float));
            (*A)[i][j][0] = 21;
        }
    }
}

#包括
#包括
无效foo（浮动*（*A）[3][3]）；
int main（int argc，字符**argv）{
浮动*A[3][3]；
foo&A；
返回0；
}
无效foo（浮动*（*A）[3][3]）{
int i，j；
对于（i=0；i你可以试试这个：

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

void foo(float *(*A)[3][3]);

int main(int argc, char **argv) {
    float* A[3][3];
    foo(&A);
    return 0;
}

void foo(float *(*A)[3][3]) {
    int i,j;
    for(i=0;i<3;i++){
        for(j=0;j<3;j++){
            (*A)[i][j] = malloc(2*sizeof(float));
            (*A)[i][j][0] = 21;
        }
    }
}

#包括
#包括
无效foo（浮动*（*A）[3][3]）；
int main（int argc，字符**argv）{
浮动*A[3][3]；
foo&A；
返回0；
}
无效foo（浮动*（*A）[3][3]）{
int i，j；
对于（i=0；i你可以试试这个：

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

void foo(float *(*A)[3][3]);

int main(int argc, char **argv) {
    float* A[3][3];
    foo(&A);
    return 0;
}

void foo(float *(*A)[3][3]) {
    int i,j;
    for(i=0;i<3;i++){
        for(j=0;j<3;j++){
            (*A)[i][j] = malloc(2*sizeof(float));
            (*A)[i][j][0] = 21;
        }
    }
}

#包括
#包括
无效foo（浮动*（*A）[3][3]）；
int main（int argc，字符**argv）{
浮动*A[3][3]；
foo&A；
返回0；
}
无效foo（浮动*（*A）[3][3]）{
int i，j；
对于（i=0；i
typeof
应该
sizeof
typeof
应该
sizeof
应该
sizeof
应该
typeof
应该
sizeof
为什么要传递
A
的地址并使之复杂化？我同意@Rik。只需声明
无效foo（float*A[3][3]）；
并调用
foo（A）；
不是
*A[3][3]
与
***A
相同？我不明白为什么它们不同。@RikayanBandyopadhyay，因为原始帖子试图这样做，所以我只是演示如何正确地做。但是是的，它是不必要的。@anthonybell不，它不是。简单地说，数组不能总是像指针一样对待。为什么要传递
A
的地址并使问题复杂化它？我同意@Rik。只要声明
无效foo（float*A[3][3]）；
并调用
foo（A）；
不是
*A[3][3]
与
***A
相同？我不明白为什么它们不同。@RikayanBandyopadhyay，因为原始帖子试图这样做，所以我只是演示如何正确地做。但是是的，它是不必要的。@anthonybell不，它不是。简单地说，数组不能总是像指针一样对待。为什么要传递
A
的地址并使问题复杂化它？我同意@Rik。只要声明
无效foo（float*A[3][3]）；
并调用
foo（A）；
不是
*A[3][3]
与
***A
相同？我不明白为什么它们不同。@RikayanBandyopadhyay，因为原始帖子试图这样做，所以我只是演示如何正确地做。但是是的，它是不必要的。@anthonybell不，它不是。简单地说，数组不能总是像指针一样对待。为什么要传递
A
的地址并使问题复杂化它？我同意@Rik。只要声明
无效foo（float*A[3][3]）；
并调用
foo（A）；
不是
*A[3][3]
与
***A
相同？我不明白为什么它们不同。@RikayanBandyopadhyay因为原始文章试图这样做，所以我只是演示如何正确地做。但是是的，它是不必要的。@anthonybell不，它不是。简单地说，数组不能总是像指针一样对待。是不是
void f（int**ap）
相当于
void f（int-ap[]]）
？不重要的区别在于声明包括列数，例如在声明
void f（int-array[][3]中）
数字
3
非常重要。原因是编译器需要该数字来计算元素的地址。例如，要定位
数组[2][1]
编译器计算地址如下
address=array\u base\u address+（（2*3）+1）*sizeof（array\u element\u type））
。如果不知道数组中的列数，地址计算是不可能的。@user3386109这里的指针声明是显式的，被调用的函数不为数组分配内存，数组不需要知道返回的行的总大小。
void f（int**ap）
是否等同于
void f（int ap[][]）
？不重要的区别在于声明包含列数，例如在声明
void f（int array[][3]）；
列数