C 将多维静态数组传递给函数

我需要一点建议。所有这三种传递静态多维数组的方式都是三维的吗，我想对于4维，它会类似于一个函数，对吗

代码如下：

#include <stdio.h>    
void fun1(int ***tab, int n, int m, int p)
{
   int i,j,k;
   for(i=0; i<n; i++)
   {
      for(j=0; j<m; j++)
      {
        for(k=0; k<p; k++)
        {
           printf("tab[%d][%d][%d] = %d\n", i, j, k, tab[i][j][k]);
        }
        printf("\n");
      }
      printf("\n");
   }
}

void fun2(int tab[2][3][2])
{
    int i,j,k;
    for(i=0; i<2; i++)
    {
       for(j=0; j<3; j++)
       {
          for(k=0; k<2; k++)
          {
             printf("tab[%d][%d][%d] = %d\n", i, j, k, tab[i][j][k]);
          }
          printf("\n");
       }
       printf("\n");
   }
}

void fun3(int tab[][3][2])
{
    int i,j,k;
    for(i=0; i<2; i++)
    {
       for(j=0; j<3; j++)
       {
          for(k=0; k<2; k++)
          {
            printf("tab[%d][%d][%d] = %d\n", i, j, k, tab[i][j][k]);
          }
          printf("\n");
      }
      printf("\n");
  }
}

int main()
{
    int tab[2][3][2] =
    {
        {{0, 1}, {2, 3}, {3, 4}},
        {{5, 6}, {7, 8}, {9, 10}}
    };

    fun1(tab,2,3,2);
    printf("--------------------------\n");
    fun2(tab);
    printf("--------------------------\n");
    fun3(tab);

    return 0;
}

---

fun1似乎有问题，但无法真正理解它的含义：应为“int***”，但参数的类型为“int*[3][2]”。这是否意味着在这种情况下只有fun2和fun3有效？

一个是指向int***的指针，另一个是指向维度为3和2 int*[3][2]的数组的指针

这些类型不兼容，它们的内存布局也不相同。数组在内存中是连续的，而指向指针的指针不是连续的

如果希望以动态方式使用第一个函数，并且在运行时已知维度，请使用其他参数声明该函数：

void fun1( int n, int m, int p , int a[n][m][p] )...

---

一个是指向int***的指针，另一个是指向维度为3和2 int*[3][2]的数组的指针

这些类型不兼容，它们的内存布局也不相同。数组在内存中是连续的，而指向指针的指针不是连续的

如果希望以动态方式使用第一个函数，并且在运行时已知维度，请使用其他参数声明该函数：

void fun1( int n, int m, int p , int a[n][m][p] )...

这是因为int***指向指向指针的指针。int*[a][b]指向int[a][b]的指针

数组在内存中是平铺的，这意味着类似int[5][5]的东西使用了与int[25]相同的空间量。使int[5][5]与int**兼容意味着需要在某个地方分配行指针。

这是因为int***指向指向指针的指针。int*[a][b]指向int[a][b]的指针

---

数组在内存中是平铺的，这意味着类似int[5][5]的东西使用了与int[25]相同的空间量。使int[5][5]与int**兼容意味着需要在某个位置分配行指针。

3D数组表达式不会退化为三重指针；它衰减为指向二维数组的指针。给定代码

int arr[X][Y][Z];
fun1( arr );

fun1调用中的表达式arr将衰减为指向int的Z元素数组的Y元素数组的指针类型，因此fun1的原型需要

void fun1( int (*table)[Y][Z] ) // or int table[][Y][Z]
{
  // do something with table[i][j][k]
}

注意，在这种情况下，Y和Z必须在编译时已知

如果您使用的C99编译器或C2011编译器仍然支持可变长度数组，则可以执行以下操作：

void fun1( size_t x, size_t y, size_t z, (*table)[y][z] ) // or table[][y][z], or table[x][y][z]
{
  // do something with table[i][j][k]
}

int main( void )
{
  int table[2][3][2] = ...;
  fun1( 2, 3, 2, table );
  ...
}

---

请注意，必须先声明x、y和z，然后才能在数组参数声明中使用它们

3D数组表达式不会衰减为三个指针；它衰减为指向二维数组的指针。给定代码

int arr[X][Y][Z];
fun1( arr );

fun1调用中的表达式arr将衰减为指向int的Z元素数组的Y元素数组的指针类型，因此fun1的原型需要

void fun1( int (*table)[Y][Z] ) // or int table[][Y][Z]
{
  // do something with table[i][j][k]
}

注意，在这种情况下，Y和Z必须在编译时已知

如果您使用的C99编译器或C2011编译器仍然支持可变长度数组，则可以执行以下操作：

void fun1( size_t x, size_t y, size_t z, (*table)[y][z] ) // or table[][y][z], or table[x][y][z]
{
  // do something with table[i][j][k]
}

int main( void )
{
  int table[2][3][2] = ...;
  fun1( 2, 3, 2, table );
  ...
}

---

请注意，必须先声明x、y和z，然后才能在数组参数声明中使用它们

可以使用fun1或fun4的实现将多维数组传递给函数

#include <stdio.h>

void fun1(int n, int m, int p, int tab[n][m][p])
{
int i,j,k;

for(i=0; i<n; i++)
{
    for(j=0; j<m; j++)
    {
        for(k=0; k<p; k++)
        {
            printf("tab[%d][%d][%d] = %d\n", i, j, k, tab[i][j][k]);
        }
        printf("\n");
    }
    printf("\n");
}
}

void fun4(int n, int m, int p, int* tab) {
int i,j,k;
for(i=0; i<n; i++)
{
    for(j=0; j<m; j++)
    {
        for(k=0; k<p; k++)
        {
            printf("tab[%d][%d][%d] = %d\n", i, j, k, tab[i*m*p+j*p+k]);
        }
        printf("\n");
    }
    printf("\n");
}
}

void fun2(int tab[2][3][2])
{
int i,j,k;

for(i=0; i<2; i++)
{
    for(j=0; j<3; j++)
    {
        for(k=0; k<2; k++)
        {
            printf("tab[%d][%d][%d] = %d\n", i, j, k, tab[i][j][k]);
        }
        printf("\n");
    }
    printf("\n");
}
}

void fun3(int tab[][3][2])
{
int i,j,k;

for(i=0; i<2; i++)
{
    for(j=0; j<3; j++)
    {
        for(k=0; k<2; k++)
        {
            printf("tab[%d][%d][%d] = %d\n", i, j, k, tab[i][j][k]);
        }
        printf("\n");
    }
    printf("\n");
}
}

int main()
{
int tab[2][3][2] =
{
    {{0, 1}, {2, 3}, {3, 4}},
    {{5, 6}, {7, 8}, {9, 10}}
};

fun1(2,3,2, tab);
printf("--------------------------\n");
fun4(2,3,2, (int*)tab);
printf("--------------------------\n");
fun2(tab);
printf("--------------------------\n");
fun3(tab);


return 0;
}

---

可以使用fun1或fun4的实现将多维数组传递给函数

#include <stdio.h>

void fun1(int n, int m, int p, int tab[n][m][p])
{
int i,j,k;

for(i=0; i<n; i++)
{
    for(j=0; j<m; j++)
    {
        for(k=0; k<p; k++)
        {
            printf("tab[%d][%d][%d] = %d\n", i, j, k, tab[i][j][k]);
        }
        printf("\n");
    }
    printf("\n");
}
}

void fun4(int n, int m, int p, int* tab) {
int i,j,k;
for(i=0; i<n; i++)
{
    for(j=0; j<m; j++)
    {
        for(k=0; k<p; k++)
        {
            printf("tab[%d][%d][%d] = %d\n", i, j, k, tab[i*m*p+j*p+k]);
        }
        printf("\n");
    }
    printf("\n");
}
}

void fun2(int tab[2][3][2])
{
int i,j,k;

for(i=0; i<2; i++)
{
    for(j=0; j<3; j++)
    {
        for(k=0; k<2; k++)
        {
            printf("tab[%d][%d][%d] = %d\n", i, j, k, tab[i][j][k]);
        }
        printf("\n");
    }
    printf("\n");
}
}

void fun3(int tab[][3][2])
{
int i,j,k;

for(i=0; i<2; i++)
{
    for(j=0; j<3; j++)
    {
        for(k=0; k<2; k++)
        {
            printf("tab[%d][%d][%d] = %d\n", i, j, k, tab[i][j][k]);
        }
        printf("\n");
    }
    printf("\n");
}
}

int main()
{
int tab[2][3][2] =
{
    {{0, 1}, {2, 3}, {3, 4}},
    {{5, 6}, {7, 8}, {9, 10}}
};

fun1(2,3,2, tab);
printf("--------------------------\n");
fun4(2,3,2, (int*)tab);
printf("--------------------------\n");
fun2(tab);
printf("--------------------------\n");
fun3(tab);


return 0;
}

---

@请让我知道你认为什么是错误的。我不是失败的选民，而且，我认为你的答案没有错。它解决了这个问题+1.@Downvoter请让我知道你认为错了什么。我不是Downvoter，而且，我认为你的答案没有错。它解决了这个问题+1.注意，在第二种情况下，需要使用int*tab或int*&tab调用函数，因为数组元素在内存中是连续的。注意，在第二种情况下，需要使用int*tab或int*&tab调用函数，因为数组元素在内存中是连续的。