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

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

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

方法一:

int a[5] = {3,3,3,3,3}; 

形式化初始化技术。

方法二:

int a[100] = {0};

但值得注意的是

int a[10] = {1}; 

不将所有值初始化为1

这种方法只对0进行初始化

如果你这样做

int a[100];

一些编译器倾向于接受垃圾值，因此它总是首选这样做

int a[1000] = {0};

有一个快速的方法来初始化任何类型的数组与给定的值。它在大型阵列上工作得非常好。算法如下:

初始化数组的第一个元素(通常的方式) 将已设置的部分复制为未设置的部分，每次复制操作都将大小增加一倍

对于1 000 000个数组元素，它比常规循环初始化快4倍(i5, 2核，2.3 GHz, 4GiB内存，64位):

循环运行时间0.004248[秒]

Memfill()运行时间0.001085[秒]

#include <stdio.h>
#include <time.h>
#include <string.h>
#define ARR_SIZE 1000000

void memfill(void *dest, size_t destsize, size_t elemsize) {
   char   *nextdest = (char *) dest + elemsize;
   size_t movesize, donesize = elemsize;

   destsize -= elemsize;
   while (destsize) {
      movesize = (donesize < destsize) ? donesize : destsize;
      memcpy(nextdest, dest, movesize);
      nextdest += movesize; destsize -= movesize; donesize += movesize;
   }
}    
int main() {
    clock_t timeStart;
    double  runTime;
    int     i, a[ARR_SIZE];

    timeStart = clock();
    for (i = 0; i < ARR_SIZE; i++)
        a[i] = 9;    
    runTime = (double)(clock() - timeStart) / (double)CLOCKS_PER_SEC;
    printf("loop runtime %f [seconds]\n",runTime);

    timeStart = clock();
    a[0] = 10;
    memfill(a, sizeof(a), sizeof(a[0]));
    runTime = (double)(clock() - timeStart) / (double)CLOCKS_PER_SEC;
    printf("memfill() runtime %f [seconds]\n",runTime);
    return 0;
}

int array[1024] = {[0 ... 1023] = 5};

如上所述很好，但请确保在…点。

用0初始化

  char arr[1000] = { 0 };

最好使用普通的“for循环”来进行除0以外的初始化。

  char arr[1000];
  for(int i=0; i<arr.size(); i++){
     arr[i] = 'A';
  }

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

#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) };

宏名称可以协商。