在C中从3D指针/数组调用2D指针/数组

对于每个时间步，我有一个2D矩阵

a[ix][iz]

，其中

ix

从

0

到

nx-1

和

iz

从

0

到

nz-1

为了组合所有时间步的矩阵，我定义了一个长度为nx*nz*nt的三维指针

***b

。在时间

it

时，矩阵可以用

b[ix][iz][it]

表示，其中

ix

从

0

变化到

nx-1

和

iz

从

0

变化到

nz-1

---

在时间循环中，我必须在时间

it

将2D数组/指针传递给函数

void func（**ptr）

。因为

b

是一个3D指针/数组，我如何在主代码中调用它？像

func（b[it]）
 您可以将矩阵重组为
b[it][ix][iz]
，而不是
b[ix][iz][it]
。这样，您就拥有了一个2D矩阵数组，允许您使用
b[it]
在任何给定的时间步传递2D矩阵

否则，如果你保持矩阵不变，你必须在时间
it
构建2D数组，然后将其传递到
func（）
-这是额外的计算，你可以通过重构3D矩阵来避免。
你可以将矩阵重构为
b[it][ix][iz]
，而不是
b[ix][iz][it]
。这样，您就拥有了一个2D矩阵数组，允许您使用
b[it]
在任何给定的时间步传递2D矩阵

否则，如果保持矩阵不变，则必须在时间
it
构建2D数组，然后将其传递到
func（）
-这是通过重新构造3D矩阵可以避免的额外计算。
最简单的方法是使用
b
仅存储指向矩阵的指针，如下所示：

在每个时间步中，复制矩阵
a
，并将指向矩阵
a
副本的指针插入
b
。
然后，您可以将
b[i]
传递给您的函数
func（b[i]）

这基本上也是frsim的建议。
代码：

#包括
#包括
#包括
#定义最长时间5
void func（整数数组[2][3]）{
对于（尺寸x=0；x<2；++x）{
用于（尺寸y=0；y<3；++y）{
printf（“%i”，数组[x][y]）；
}
printf（“\n”）；
}
printf（“\n”）；
}
int main（int argc，字符**argv）{
INTA[2][3]={{1,2,3}，{4,5,6}；
int b[MAX_TIME][2][3]={0}；
用于（大小时间=0；时间<最大时间；++时间）{
/*在这里计算你的新版本的'a'*/
a[1][0]=时间；
memcpy（b[时间]、a、sizeof（a））；
printf（“%zu”，sizeof（a））；
}
对于（大小i=0；i

数组有很多陷阱，特别是数组不是指针

但是：如果将数组传递给函数，所发生的事情不是将数组本身传递给函数，而是传递给数组的指针。
二维数组也会发生同样的情况：当使用二维数组调用函数时，传递到函数中的不是数组，而是指针，该指针仍然是
int*
而不是
int**
。。。例如，请参见
最简单的方法是使用
b
存储指向矩阵的指针，如下所示：

在每个时间步中，复制矩阵
a
，并将指向矩阵
a
副本的指针插入
b
。
然后，您可以将
b[i]
传递给您的函数
func（b[i]）

这基本上也是frsim的建议。
代码：

#包括
#包括
#包括
#定义最长时间5
void func（整数数组[2][3]）{
对于（尺寸x=0；x<2；++x）{
用于（尺寸y=0；y<3；++y）{
printf（“%i”，数组[x][y]）；
}
printf（“\n”）；
}
printf（“\n”）；
}
int main（int argc，字符**argv）{
INTA[2][3]={{1,2,3}，{4,5,6}；
int b[MAX_TIME][2][3]={0}；
用于（大小时间=0；时间<最大时间；++时间）{
/*在这里计算你的新版本的'a'*/
a[1][0]=时间；
memcpy（b[时间]、a、sizeof（a））；
printf（“%zu”，sizeof（a））；
}
对于（大小i=0；i

数组有很多陷阱，特别是数组不是指针

但是：如果将数组传递给函数，所发生的事情不是将数组本身传递给函数，而是传递给数组的指针。
二维数组也会发生同样的情况：当使用二维数组调用函数时，传递到函数中的不是数组，而是指针，该指针仍然是
int*
而不是
int**
。。。例如，请参见
“但是指向数组的指针”->“但是指向数组的第一个元素的指针”。“但是指向数组的指针”->“但是指向数组的第一个元素的指针”。
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define MAX_TIME 5

void func(int array[2][3]) {

    for(size_t x = 0; x < 2; ++x) {

        for(size_t y = 0; y < 3; ++y) {
            printf("%i ", array[x][y]);
        }
        printf("\n");

    }
    printf("\n");

}

int main (int argc, char** argv) {

   int a[2][3] = {{1, 2, 3}, {4, 5, 6}};

   int b[MAX_TIME][2][3] = {0};

   for(size_t time = 0; time < MAX_TIME; ++time) {

       /* Calculate your new version of `a` here */

       a[1][0] = time;

       memcpy(b[time], a, sizeof(a));
       printf("%zu ", sizeof(a));

   }

   for(size_t i = 0; i < MAX_TIME; ++i) {
       printf("time: %zu \n", i);
       func(b[i]);
   }

}