C 谁能简化下面的代码结构{inta[2]；}arr[]={{{1}，{2}；？

请特别简化上述代码

arr[]={{{1}，{2}零件及其与结构的关系


p、 s.：-
arr[]={{1}，{2}
初始化似乎是一个
2d数组
，但左值赋值是对
1d数组（arr[]）
完成的。同样，如果我们调用
arr[].a[2]
，那么
a[2]
会保留什么

struct {int a[2];} arr[] = {{1},{2}};

到目前为止，上述初始化尚未完成，您应该看到以下警告

struct {int a[2];} arr[] = {{1},{2}};

正确的初始化是

warning: (near initialization for ‘arr[0].a’)


到目前为止，上述初始化尚未完成，您应该看到以下警告

struct {int a[2];} arr[] = {{1},{2}};

正确的初始化是

warning: (near initialization for ‘arr[0].a’)


简化
struct{inta[2]；}arr[]={{1}，{2}

简化
struct{inta[2]；}arr[]={{1}，{2}

首先，让我们掌握聚合（数组或结构）初始化的规则。在6.7.9，初始化中说明：

17每个括号内的初始值设定项列表都有一个关联的当前对象。当不存在指定时，将按[…]顺序初始化当前对象的子对象

因此，初始化器列表也会初始化子对象（即使没有内括号）

最外层支撑对内的当前对象是结构数组
arr
。内括号对内的当前对象是数组的元素，
arr[i]
。
arr
的初始化器列表中有两个子初始化器列表，使
arr
的元素计数为2

内部初始值设定项列出了
{1}
resp<代码>{2}
用于初始化单个未命名结构。每个结构
arr[i]
依次包含一个聚合，即成员数组
a
，因此以下规则很重要：

如果聚合或联合包含聚合[…]的元素或成员，这些规则递归地应用于子聚合[…]

arr[0]
中结构的初始值设定项列表是
{1}
，因此使用单个元素
1
初始化其元素。唯一的元素是
a
，一个由2个整数组成的数组。由于递归规则，1用于按顺序初始化此子聚合。因为所有
arr[0]只有一个初始值设定项，
a`中的第二个int元素没有匹配的初始值设定项。以下规则在这里起作用：

19[…]所有未显式初始化的子对象应隐式初始化，与具有静态存储持续时间的对象相同。

静态对象为零初始化（6.7.9/10）

同样的推理适用于
arr
中的第二个元素

这样我们就得到了一个
arr
，它有两个元素，每个元素都是一个未命名的结构，包含一个2 int的数组，其中第一个元素用给定的值初始化，第二个元素隐式地用零初始化

让我们玩一下这些规则。例如，我们可以不提供初始化器，零初始化自动变量的所有成员/元素。（在这种情况下，我有多少次看到人们使用memset！）

根据您的示例构建：

    struct jumble { int i; char *p; float f; };
    void f() { struct jumble arr[10] = {}; /* zero numbers, nullpointer */ }

首先，让我们掌握聚合（数组或结构）初始化的规则。在6.7.9，初始化中说明：

17每个括号内的初始值设定项列表都有一个关联的当前对象。当不存在指定时，将按[…]顺序初始化当前对象的子对象

因此，初始化器列表也会初始化子对象（即使没有内括号）

最外层支撑对内的当前对象是结构数组
arr
。内括号对内的当前对象是数组的元素，
arr[i]
。
arr
的初始化器列表中有两个子初始化器列表，使
arr
的元素计数为2

内部初始值设定项列出了
{1}
resp<代码>{2}
用于初始化单个未命名结构。每个结构
arr[i]
依次包含一个聚合，即成员数组
a
，因此以下规则很重要：

如果聚合或联合包含聚合[…]的元素或成员，这些规则递归地应用于子聚合[…]

arr[0]
中结构的初始值设定项列表是
{1}
，因此使用单个元素
1
初始化其元素。唯一的元素是
a
，一个由2个整数组成的数组。由于递归规则，1用于按顺序初始化此子聚合。因为所有
arr[0]只有一个初始值设定项，
a`中的第二个int元素没有匹配的初始值设定项。以下规则在这里起作用：

19[…]所有未显式初始化的子对象应隐式初始化，与具有静态存储持续时间的对象相同。

静态对象为零初始化（6.7.9/10）

同样的推理适用于
arr
中的第二个元素

这样我们就得到了一个
arr
，它有两个元素，每个元素都是一个未命名的结构，包含一个2 int的数组，其中第一个元素用给定的值初始化，第二个元素隐式地用零初始化

让我们玩一下这些规则。例如，我们可以不提供初始化器，零初始化自动变量的所有成员/元素。（在这种情况下，我有多少次看到人们使用memset！）

根据您的示例构建：

    struct jumble { int i; char *p; float f; };
    void f() { struct jumble arr[10] = {}; /* zero numbers, nullpointer */ }

如何简化？你的问题到底是什么
arr
是由2个元素组成的数组，每个元素都是一个结构
#include<stdio.h>

struct int2T { int a[2]; };

void printStructArr(const char *name, struct int2T *arr, size_t numElems)
{
    for(int arri=0; arri<numElems; arri++)
    {
        for(int ai=0; ai < sizeof(arr[arri].a)/sizeof(*arr[arri].a); ai++)
        {   fputs(name, stdout);
            printf("[%d].a[%d]: %d\n", arri, ai, arr[arri].a[ai]);
        }
    }
    printf("\n");
}

int main()
{
    struct int2T arr1[] = {{1},{2}};
    // equivalent: Proper bracing
    struct int2T arr1b[] = { // arr                    array of structs               
                              { // arr[0]              single struct
                                 { // arr[0].a         member array within struct
                                    1, // arr[0].a[0]  int
                                    0  // arr[0].a[1]  int
                                 }
                              },
                              { // arr[1]              single struct
                                 { // arr[1].a         member array within struct
                                    2, // arr[1].a[0]  int
                                    0  // arr[1].a[1]  int
                                 }
                              }
    };

    struct int2T arr2[] = { // arr, array of structs
                            11, // trying to initialize arr[0] 
                                   // -> recursing: trying to initialize arr[0].a
                                        // -> recursing: trying to initialize arr[0].a[0]. Success!

                            12 }; // same as above.
    struct int2T arr3[] = { 
                            21, // trying to initialize arr[0] 
                                   // -> recursing: trying to initialize arr[0].a
                                        // -> recursing: trying to initialize arr[0].a[0]. Success!
                            22,         //  next element in array, initialize arr[0].a[1]. Success!
                            23          // elements in inner array "a" exhausted, unwind recursion
                                   // trying to continue initializing arr[0]. No more members to initialize, 
                                   // unwinding recursion to next upper level.
                                // trying to initialize next element in array "arr", arr[1] 
                                    // -> recursing: trying to initialize arr[1].a
                                        // -> recursing: trying to initialize arr[1].a[0]. Success!
                                        // no more initializer left for arr[1].a[1] 
                                        // -> Zero-initialize arr[1].a[1], then unwind.
                                    // Continuing initialization of arr[1]: No more members, unwind
                                // Continuing initialization of arr: No more initializers left, stop.
                          };


    printStructArr("arr1", arr1, sizeof(arr1)/sizeof(*arr1));
    printStructArr("arr1b", arr1b, sizeof(arr1b)/sizeof(*arr1b));
    printStructArr("arr2", arr2, sizeof(arr2)/sizeof(*arr2));
    printStructArr("arr3", arr3, sizeof(arr3)/sizeof(*arr3));

    return 0;
}

arr1[0].a[0]: 1
arr1[0].a[1]: 0
arr1[1].a[0]: 2
arr1[1].a[1]: 0

arr1b[0].a[0]: 1
arr1b[0].a[1]: 0
arr1b[1].a[0]: 2
arr1b[1].a[1]: 0

arr2[0].a[0]: 11
arr2[0].a[1]: 12

arr3[0].a[0]: 21
arr3[0].a[1]: 22
arr3[1].a[0]: 23
arr3[1].a[1]: 0