有时候，我们需要在代码里配置一些常量结构，比如一个固定的动作流程ActionFlow：包含N（即flow_num）个动作列表（ActionArray），每个动作列表包含M（即act_num）个可并行执行的动作ID。

// 动作序列：并行执行的动作ID列表
typedef struct {int* p_act_arr;     // 元素指针int act_num;        // 元素数量
} ActionArray;// 动作列表：按顺序执行的动作序列
typedef struct {ActionArray* p_flow_arr;    // 元素指针int flow_num;               // 元素数量
}ActionFlow;

直观看，我们希望这样配置，一目了然，但这不符合C/C++的语法规则

// 配置固定的动作序列
ActionFlow g_act_flow = {{{{1, 2},          2},     // 第0个可并行执行的动作{{3, 4, 5, 6, 7}, 5},     // 第1个{{8},             1},     // 第2个},3                             // 共3个
};

符合规则的语法大概是这样的，看起来显得有些冗长

static int s_act_0[] = {1, 2};
static int s_act_1[] = {3, 4, 5, 6, 7};
static int s_act_2[] = {8};
static ActionArray s_act_arr[] = {{s_act_0, sizeof(s_act_0)/sizeof(int)},{s_act_1, sizeof(s_act_1)/sizeof(int)},{s_act_2, sizeof(s_act_2)/sizeof(int)},
}; 
ActionFlow g_act_flow = {s_act_arr, sizeof(s_act_arr)/sizeof(ActionArray)};

为了让定义更简洁，尽可能的只提供{1,2},{3,4,5,6,7}这些我们关心的业务数据，我们可以使用C99中引入的复合字面量（compound literals，对应C++中的列表初始化‌（list initialization））来简化上述的变长嵌套数组常量初始化定义：

#define ARRAY(type, ...) (type[])__VA_ARGS__, sizeof((type[])__VA_ARGS__)/sizeof(type)
#define ACTARR(...) ARRAY(int, __VA_ARGS__)
#define ACTIONFLOW(name, ...) ActionFlow g_##name = {ARRAY(ActionArray, __VA_ARGS__)}
ACTIONFLOW(act_flow, {         \{ACTARR({1, 2})},          \{ACTARR({3, 4, 5, 6, 7})}, \{ACTARR({8})}              \
});

还有更简洁实用的方法吗？欢迎留言讨论。