Struct and union initialization

当初始化 结构体 或 联合体 类型的对象时，初始化器必须是由成员初始化器组成的 非空 (C23前) 花括号括起的逗号分隔列表：

其中 指示符 是由单个成员指示符（形式为 . 成员 ）和 数组指示符 （形式为 [ 索引 ] ）组成的序列（以空格分隔或相邻）。

所有未显式初始化的成员都将被 空初始化 。

说明

当初始化 联合体 时，初始化列表只能包含一个成员，该成员用于初始化联合体的第一个成员 除非使用指定初始化器 (C99起) 。

union { int x; char c[4]; }
  u = {1},           // 使 u.x 成为活动成员，其值为 1
 u2 = { .c={'\1'} }; // 使 u2.c 成为活动成员，其值为 {'\1','\0','\0','\0'}

初始化 结构体 时，列表中的首个初始化式会初始化首个声明的成员 （除非指定了指示符） (C99起) ，而所有后续 不带指示符的 (C99起) 初始化式会初始化前一个表达式所初始化成员之后声明的结构体成员。

struct point {double x,y,z;} p = {1.2, 1.3}; // p.x=1.2, p.y=1.3, p.z=0.0
div_t answer = {.quot = 2, .rem = -1 };      // div_t 结构体中元素的顺序可能有所不同

struct {int sec,min,hour,day,mon,year;} z
   = {.day=31,12,2014,.sec=30,15,17}; // initializes z to {30,15,17,31,12,2014}

提供比成员数量更多的初始化器是错误的。

嵌套初始化

如果结构体或联合体的成员是数组、结构体或联合体，则在大括号括起的初始化器列表中对应的初始化器可以是适用于这些成员的任何初始化器，但可按以下方式省略其大括号：

如果嵌套初始化器以左花括号开始，整个嵌套初始化器直到其右花括号为止将初始化对应的成员对象。每个左花括号都会建立一个新的 当前对象 。当前对象的成员按其自然顺序进行初始化 ，除非使用了指示符 (C99起) ：数组元素按下标顺序，结构体成员按声明顺序，联合体仅初始化首个声明成员。当前对象中未被右花括号显式初始化的子对象将被 空初始化 。

struct example {
    struct addr_t {
       uint32_t port;
    } addr;
    union {
       uint8_t a8[4];
       uint16_t a16[2];
    } in_u;
};
struct example ex = { // struct example 初始化列表开始
                     { // ex.addr 初始化列表开始
                        80 // 初始化结构体唯一成员
                     }, // ex.addr 初始化列表结束
                     { // ex.in_u 初始化列表开始
                        {127,0,0,1} // 初始化联合体的首个元素
                     } };

如果嵌套初始化器不是以左花括号开始，则仅从列表中取用足够数量的初始化器来对应成员数组、结构体或联合体的元素或成员；任何剩余的初始化器将留作初始化下一个结构体成员：

struct example ex = {80, 127, 0, 0, 1}; // 80 初始化 ex.addr.port
                                        // 127 初始化 ex.in_u.a8[0]
                                        // 0 初始化 ex.in_u.a8[1]
                                        // 0 初始化 ex.in_u.a8[2]
                                        // 1 初始化 ex.in_u.a8[3]

struct example ex2 = { // 当前对象是 ex2，指示符用于 example 的成员
                       .in_u.a8[0]=127, 0, 0, 1, .addr=80}; 
struct example ex3 = {80, .in_u={ // 将当前对象更改为联合体 ex.in_u
                           127,
                           .a8[2]=1 // 此指示符引用 in_u 的成员
                      } };

struct {int n;} s = {printf("a\n"), // 此行可能被打印或跳过
                     .n=printf("b\n")}; // 始终会被打印

#include <stdio.h>
typedef struct { int k; int l; int a[2]; } T;
typedef struct { int i;  T t; } S;
T x = {.l = 43, .k = 42, .a[1] = 19, .a[0] = 18 };
 // x 初始化为 {42, 43, {18, 19} }
int main(void)
{
    S l = { 1,          // 将 l.i 初始化为 1
           .t = x,      // 将 l.t 初始化为 {42, 43, {18, 19} }
           .t.l = 41,   // 将 l.t 更改为 {42, 41, {18, 19} }
           .t.a[1] = 17 // 将 l.t 更改为 {42, 41, {18, 17} }
          };
    printf("l.t.k is %d\n", l.t.k); // .t = x 显式将 l.t.k 设为 42
                                    // .t.l = 41 会隐式清零 l.t.k
}

l.t.k is 42

struct fred { char s[4]; int n; };
struct fred x[ ] = { { { "abc" }, 1 }, // 将 x[0] 初始化为 { {'a','b','c','\0'}, 1 }
                      [0].s[0] = 'q'   // 将 x[0] 更改为 { {'q','b','c','\0'}, 1 }
                   };
struct fred y[ ] = { { { "abc" }, 1 }, // 将 y[0] 初始化为 { {'a','b','c','\0'}, 1 }
                     [0] = { // 当前对象现在是整个 y[0] 对象
                             .s[0] = 'q' 
                            } // 将 y[0] 替换为 { {'q','\0','\0','\0'}, 0 }
                    };

注释

初始化列表可以包含一个被忽略的尾随逗号。

struct {double x,y;} p = {1.0,
                          2.0, // 末尾逗号允许
                          };

struct {int n;} s = {0}; // 正确
struct {int n;} s = {}; // C23 前错误：初始化列表不能为空
                        // C23 起正确：s.n 被初始化为 0
struct {} s = {}; // 错误：结构体不能为空

static struct {char* p} s = {malloc(1)}; // error

int n = 1;
struct {int x,y;} p = {n++, n++}; // 未指定但行为良好定义：
                                  // n以任意顺序递增两次
                                  // p等于{1,2}和{2,1}均有效

示例

#include <stdio.h>
#include <time.h>
int main(void)
{
    char buff[70];
    // 指定初始化器简化了成员顺序未指定的结构体的使用
    struct tm my_time = { .tm_year=2012-1900, .tm_mon=9, .tm_mday=9,
                          .tm_hour=8, .tm_min=10, .tm_sec=20 };
    strftime(buff, sizeof buff, "%A %c", &my_time);
    puts(buff);
}

Sunday Sun Oct  9 08:10:20 2012

参考文献

参见