在C中初始化高维数组的最佳方法是什么？

假设我有一个9维数组：

int arr[4][4][4][4][4][4][4][4][4];

我想将每个元素初始化为1

我知道我可以使用多个循环来初始化它：

for(int i1 = 0; i1 < 4; i ++) {
     ...// eight more similiar loops
}

for（inti1=0；i1<4；i++）{
…//又有八个类似的循环
}

但它看起来很丑陋

这样做的最佳实践是什么？也许我可以用宏？

这样写：

int *p = &arr[0][0][0][0][0][0][0][0][0];
for( int i = 0; i < 4*4*4*4*4*4*4*4*4; i++)
    *p++ = 1;

所以

但是如果你在这里传递一个指针

int* arr;
sizeof(arr) = sizeof(int*)
            = sizeof(void*)
            = Usually the target file's BIT / 8

这样写：

int *p = &arr[0][0][0][0][0][0][0][0][0];
for( int i = 0; i < 4*4*4*4*4*4*4*4*4; i++)
    *p++ = 1;

所以

但是如果你在这里传递一个指针

int* arr;
sizeof(arr) = sizeof(int*)
            = sizeof(void*)
            = Usually the target file's BIT / 8

这样写：

int *p = &arr[0][0][0][0][0][0][0][0][0];
for( int i = 0; i < 4*4*4*4*4*4*4*4*4; i++)
    *p++ = 1;

所以

但是如果你在这里传递一个指针

int* arr;
sizeof(arr) = sizeof(int*)
            = sizeof(void*)
            = Usually the target file's BIT / 8

这样写：

int *p = &arr[0][0][0][0][0][0][0][0][0];
for( int i = 0; i < 4*4*4*4*4*4*4*4*4; i++)
    *p++ = 1;

所以

但是如果你在这里传递一个指针

int* arr;
sizeof(arr) = sizeof(int*)
            = sizeof(void*)
            = Usually the target file's BIT / 8

---

在C语言中，多维数组是连续的，因此可以通过指针初始化arr来利用这一点

    int* parr = (int*)arr;
    for (int i = 0; i < ((sizeof(arr)/sizeof(int)); ++i)
        parr[i] = 1;

int*parr=（int*）arr；
对于（int i=0；i<（（sizeof（arr）/sizeof（int））；++i）
parr[i]=1；

---

请注意，在数组分解为指针的情况下（例如，如果它作为参数传递给函数），这不起作用。

在C中，多维数组是连续的，因此可以通过指针初始化arr来利用这一点

    int* parr = (int*)arr;
    for (int i = 0; i < ((sizeof(arr)/sizeof(int)); ++i)
        parr[i] = 1;

int*parr=（int*）arr；
对于（int i=0；i<（（sizeof（arr）/sizeof（int））；++i）
parr[i]=1；

---

请注意，在数组分解为指针的情况下（例如，如果它作为参数传递给函数），这不起作用。

在C中，多维数组是连续的，因此可以通过指针初始化arr来利用这一点

    int* parr = (int*)arr;
    for (int i = 0; i < ((sizeof(arr)/sizeof(int)); ++i)
        parr[i] = 1;

int*parr=（int*）arr；
对于（int i=0；i<（（sizeof（arr）/sizeof（int））；++i）
parr[i]=1；

---

请注意，在数组分解为指针的情况下（例如，如果它作为参数传递给函数），这不起作用。

在C中，多维数组是连续的，因此可以通过指针初始化arr来利用这一点

    int* parr = (int*)arr;
    for (int i = 0; i < ((sizeof(arr)/sizeof(int)); ++i)
        parr[i] = 1;

int*parr=（int*）arr；
对于（int i=0；i<（（sizeof（arr）/sizeof（int））；++i）
parr[i]=1；

---

请注意，在数组分解为指针的情况下（例如，如果它作为参数传递给函数），这将不起作用。

可能使用递归函数，该函数传递了需要初始化的数字级别

void init(int * arr, int level, int size, int value)
{
     for(int i = 0; i < size; i++)
     {
          if(level == 0)
              arr[i] = value;
          else
              init(arr[i], level - 1, size, value);
     }
}

void init（int*arr，int-level，int-size，int-value）
{
对于（int i=0；i

可能使用递归函数，该函数传递了需要初始化的数字级别

void init(int * arr, int level, int size, int value)
{
     for(int i = 0; i < size; i++)
     {
          if(level == 0)
              arr[i] = value;
          else
              init(arr[i], level - 1, size, value);
     }
}

void init（int*arr，int-level，int-size，int-value）
{
对于（int i=0；i

可能使用递归函数，该函数传递了需要初始化的数字级别

void init(int * arr, int level, int size, int value)
{
     for(int i = 0; i < size; i++)
     {
          if(level == 0)
              arr[i] = value;
          else
              init(arr[i], level - 1, size, value);
     }
}

void init（int*arr，int-level，int-size，int-value）
{
对于（int i=0；i

可能使用递归函数，该函数传递了需要初始化的数字级别

void init(int * arr, int level, int size, int value)
{
     for(int i = 0; i < size; i++)
     {
          if(level == 0)
              arr[i] = value;
          else
              init(arr[i], level - 1, size, value);
     }
}

void init（int*arr，int-level，int-size，int-value）
{
对于（int i=0；i

如果您想初始化为零，那么一个好的

旧内存集就可以做到：

int arr[4][4][4][4][4][4][4][4][4];
memset(&arr, 0, sizeof(arr));

不过，也就是说，既然你想初始化为1，我应该说，在C中使用9D数组通常看起来是一个至少有点糟糕的主意。你总是必须在你传递给函数的任何地方声明那个严格的类型，而且你永远不能以任何通用的方式使用间接索引。你可能最好只是声明一个218大的
int
-数组，然后手动计算索引。当然，这是您的上下文，所以这并不是说您不可能有自己的理由。
如果您想初始化为零，一个好的旧
memset
就可以做到：

int arr[4][4][4][4][4][4][4][4][4];
memset(&arr, 0, sizeof(arr));

不过，也就是说，既然你想初始化为1，我应该说，在C中使用9D数组通常看起来是一个至少有点糟糕的主意。你总是必须在你传递给函数的任何地方声明那个严格的类型，而且你永远不能以任何通用的方式使用间接索引。你可能最好只是声明一个218大的
int
-数组，然后手动计算索引。当然，这是您的上下文，所以这并不是说您不可能有自己的理由。
如果您想初始化为零，一个好的旧
memset
就可以做到：

int arr[4][4][4][4][4][4][4][4][4];
memset(&arr, 0, sizeof(arr));

不过，也就是说，既然你想初始化为1，我应该说，在C中使用9D数组通常看起来是一个至少有点糟糕的主意。你总是必须在你传递给函数的任何地方声明那个严格的类型，而且你永远不能以任何通用的方式使用间接索引。你可能最好只是声明一个218大的
int
-数组，然后手动计算索引。当然，这是您的上下文，所以这并不是说您不可能有自己的理由。
如果您想初始化为零，一个好的旧
memset
就可以做到：

int arr[4][4][4][4][4][4][4][4][4];
memset(&arr, 0, sizeof(arr));

不过，也就是说，既然你想初始化为1，我应该说，在C中使用9D数组通常看起来是一个至少有点糟糕的主意。你总是必须在你传递给函数的任何地方声明那个严格的类型，而且你永远不能以任何通用的方式使用间接索引。你可能最好只是声明218大
int
-数组并计算索引