C 初始化数组的快速方法

我有一个int数组，我必须用值-1初始化这个数组。现在我使用这个循环：

int i;
int myArray[10];

for(i = 0; i < 10; i++)
    myArray[i] = -1;

inti；
int-myArray[10]；
对于（i=0；i<10；i++）
myArray[i]=-1；

---

有更快的方法吗？

我所知道的值

-1

（或

0

）的最快方法是：

无论如何，您可以通过以下方式优化循环：

int i;
for(i = 10; i--;)
    v[i] = -1;

---

memset

速度非常快

int arr[10];
memset(arr, -1, sizeof(arr));

---

然而，无论如何，优化编译器都可能会将您所拥有的转换为对memset的调用。查看程序集输出以确保，但编译时循环不太可能保持为循环。

在GNU C中，您可以做的是：

int myArray[10] = {[0 ... 9] = -1};

初始化一系列元素：

正如没人提到的，在便携式C中：

int myArray[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};

---

如果要在声明时使用0初始化数组，可以使用：

inta[10]={0}这是非常快的。但是，如果要使用其他值进行初始化，或者要在代码后面的某个时间使用0重新初始化数组，请使用：
memset（a，-1，大小a）（或
memset（分别为a、0、size_a）
）或循环。在我看来，总是喜欢
memset（）
而不是循环，因为
memset（）
经常被优化为将内存中的整个单词设置为作为其参数给定的初始化值，而不是设置单个字节

对于统计数据，在我安装的32位Linux上，使用4GB内存和2.2GHz*2处理器，以下给出了四种类型的阵列初始化代码的运行时间：

1） 。0.002s

#包括
#定义大小1000000
int a[大小]；
内部主（空）
{
返回0；
}

2） 。0.008s

#包括
#定义大小1000000
内部主（空）
{
int a[SIZE]={0}；
返回0；
}

3） 。0.003s

#包括
#定义大小1000000
内部主（空）
{
int a[大小]；
内存集（a，-1，大小）；
返回0；
}

4） 。0.011s

#包括
#定义大小1000000
内部主（空）
{
int a[大小]；
int i；
对于（i=0；i
在两台互补机器上。不适用于像符号和大小这样的异国情调。但是，由于当今世界都是二的补充，是的。@Nick这不是C，而是C的GNU扩展（默认情况下使用gcc启用）。任何健全的优化编译器都会将简单的分配循环优化为调用
memset
。是的，使用
-O2
或
-O3
，gcc 4.5.2确实优化了分配循环，使之与汇编代码类似。
int myArray[10] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};

#include <string.h>

#define SIZE 1000000

int a[SIZE];

int main(void)
{
    return 0;
}

#include <string.h>

#define SIZE 1000000

int main(void)
{
    int a[SIZE] = {0};
    return 0;
}

#include <string.h>

#define SIZE 1000000

int main(void)
{
    int a[SIZE];
    memset(a, -1, SIZE);
    return 0;
}

#include <string.h>

#define SIZE 1000000

int main(void)
{
    int a[SIZE];
    int i;
    for(i = 0; i < SIZE; i++)
        a[i] = -1;
    return 0;
}