如果你想确保数组的每个成员都被显式初始化，只需从声明中省略维度:

int myArray[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

编译器将从初始化列表中推导出维度。不幸的是，对于多维数组，只有最外层的维度可能被省略:

int myPoints[][3] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9} };

还可以，但是

int myPoints[][] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9} };

不是。

我看到了一些使用这种语法的代码:

char* array[] = 
{
    [0] = "Hello",
    [1] = "World"
};   

它变得特别有用的地方是当你创建一个使用枚举作为索引的数组时:

enum
{
    ERR_OK,
    ERR_FAIL,
    ERR_MEMORY
};

#define _ITEM(x) [x] = #x

char* array[] = 
{
    _ITEM(ERR_OK),
    _ITEM(ERR_FAIL),
    _ITEM(ERR_MEMORY)
};   

这使事情保持有序，即使您碰巧把一些枚举值写成了无序的顺序。

关于这项技术的更多信息可以在这里和这里找到。

int i;
for (i = 0; i < ARRAY_SIZE; ++i)
{
  myArray[i] = VALUE;
}

我觉得这比

int myArray[10] = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5...

以防数组的大小发生变化。

略带开玩笑的回答;写语句

array = initial_value

用你最喜欢的支持数组的语言(我的是Fortran，但还有很多其他语言)，并将它链接到你的C代码。你可能想把它包装成一个外部函数。

对于静态初始化具有相同值的大型数组，不需要多次复制粘贴，你可以使用宏:

#define VAL_1X     42
#define VAL_2X     VAL_1X,  VAL_1X
#define VAL_4X     VAL_2X,  VAL_2X
#define VAL_8X     VAL_4X,  VAL_4X
#define VAL_16X    VAL_8X,  VAL_8X
#define VAL_32X    VAL_16X, VAL_16X
#define VAL_64X    VAL_32X, VAL_32X

int myArray[53] = { VAL_32X, VAL_16X, VAL_4X, VAL_1X };

如果需要更改值，则只能在一个位置进行替换。

编辑:可能有用的扩展

(乔纳森·莱弗勒提供)

你可以很容易地概括这一点:

#define VAL_1(X) X
#define VAL_2(X) VAL_1(X), VAL_1(X)
/* etc. */

可以使用以下命令创建变量:

#define STRUCTVAL_1(...) { __VA_ARGS__ }
#define STRUCTVAL_2(...) STRUCTVAL_1(__VA_ARGS__), STRUCTVAL_1(__VA_ARGS__)
/*etc */ 

这适用于结构或复合数组。

#define STRUCTVAL_48(...) STRUCTVAL_32(__VA_ARGS__), STRUCTVAL_16(__VA_ARGS__)

struct Pair { char key[16]; char val[32]; };
struct Pair p_data[] = { STRUCTVAL_48("Key", "Value") };
int a_data[][4] = { STRUCTVAL_48(12, 19, 23, 37) };

宏名称可以协商。

你可以像上面详细描述的那样做整个静态初始化器的事情，但是当你的数组大小发生变化时(当你的数组变大时，如果你没有添加适当的额外初始化器，你就会得到垃圾)，这可能是一个真正的麻烦。

Memset为您的工作提供了一个运行时命中，但是任何正确的代码大小命中都不受数组大小变化的影响。当数组大于几十个元素时，我几乎在所有情况下都会使用这个解决方案。

如果静态声明数组真的很重要，我会写一个程序来为我编写程序，并使其成为构建过程的一部分。