编译原理—多维数组声明、数组元素初始化规则

C语言多维数组声明元素初始化规则

如图，是一个较复杂的高维数组初始化，那么以上元素对应的各维下标应该是怎样的呢？

⾼维数组初始化，总结的⼤致规律是：

⼤括号中的每个元素依次初始化数组的⼀个地址，或者⼀块
连续地址:

1. 如果元素是数字，那就直接初始化该地址
2. 如果元素是有⼤括号的，那么⽤它来初始化⼀块连续地
   址，这块地址对应以当前位置作为起点的最⾼维的数组
   
   可以看到，如果大括号前面已经有完整的2x2一块或者他是起点，那么直接初始化一块连续的地址，不足补0；如果他前面有不足2*2个元素，那么把他带进去，后面补0；

则上述求下标结果如下

下列四个数组的声明是相同的

int main(void)
{
    // 下列四个数组的声明是相同的
    short q1[4][3][2] = {
        { 1 },
        { 2, 3 },
        { 4, 5, 6 }
    };
 
    short q2[4][3][2] = {1, 0, 0, 0, 0, 0, 2, 3, 0, 0, 0, 0, 4, 5, 6};
 
    short q3[4][3][2] = {
        {
            { 1 },
        },
        {
            { 2, 3 },
        },
        {
            { 4, 5 },
            { 6 },
        }
    };
 
    short q4[4][3][2] = {1, [1]=2, 3, [2]=4, 5, 6};
 
 
    // 下标能与枚举常量关联
    // 使用带指派符的数组：
    enum { RED, GREEN, BLUE };
    const char *nm[] = {
        [RED] = "red",
        [GREEN] = "green",
        [BLUE] = "blue",
    };
}

嵌套数组

若数组的元素是数组、结构体或联合体，则对应的花括号环绕的初始化器列表中的初始化器是任何对于那些成员合法的初始化器，除了它们的花括号可以按如下方式省略：
若嵌套初始化器从左花括号开始，则整个直到其右花括号为止的初始化器初始化对应的数组元素：

int y[4][3] = { // 4 个 3 个 int 的数组的数组（ 4*3 矩阵）
    { 1 },      // 0 行初始化到 {1, 0, 0}
    { 0, 1 },   // 1 行初始化到 {0, 1, 0}
    { [2]=1 },  // 2 行初始化到 {0, 0, 1}
};              // 3 行初始化到 {0, 0, 0}

若嵌套初始化器不从左花括号开始，则只有的来自列表的充足的初始化器会被用于说明子数组、结构体或联合体；任何剩下的初始化器都被留作初始化下一个数组元素：

int y[4][3] = {    // 4 个 3 个 int 的数组的数组（ 4*3 矩阵）
1, 3, 5, 2, 4, 6, 3, 5, 7 // 0 行初始化到 {1, 3, 5}
};                        // 1 行初始化到 {2, 4, 6}
                          // 2 行初始化到 {3, 5, 7}
                          // 3 行初始化到 {0, 0, 0}