在 C 中将二维数组归零的最快方法是什么？

Question

我想在 C 中反复将一个大型二维数组归零。这就是我现在所做的：

// Array of size n * m, where n may not equal m
for(j = 0; j < n; j++)
{
    for(i = 0; i < m; i++)
    {  
        array[i][j] = 0;
    }
}

我尝试过使用 memset：

memset(array, 0, sizeof(array))

但这仅适用于一维数组。当我 printf 二维数组的内容时，第一行为零，但随后我得到了大量随机大数，它崩溃了。

Answer 1

如果array 确实是一个数组，那么您可以使用以下命令将其“归零”：

memset(array, 0, sizeof array);

但是有两点你应该知道：

• 仅当 array 确实是“二维数组”时才有效，即，对于某些类型 T 声明为 T array[M][N];。
• 它仅在声明array 的范围内有效。如果将其传递给函数，则名称 array decays to a pointer 和 sizeof 不会为您提供数组的大小。

让我们做一个实验：

#include <stdio.h>

void f(int (*arr)[5])
{
    printf("f:    sizeof arr:       %zu\n", sizeof arr);
    printf("f:    sizeof arr[0]:    %zu\n", sizeof arr[0]);
    printf("f:    sizeof arr[0][0]: %zu\n", sizeof arr[0][0]);
}

int main(void)
{
    int arr[10][5];
    printf("main: sizeof arr:       %zu\n", sizeof arr);
    printf("main: sizeof arr[0]:    %zu\n", sizeof arr[0]);
    printf("main: sizeof arr[0][0]: %zu\n\n", sizeof arr[0][0]);
    f(arr);
    return 0;
}

在我的机器上，上面的打印：

main: sizeof arr:       200
main: sizeof arr[0]:    20
main: sizeof arr[0][0]: 4

f:    sizeof arr:       8
f:    sizeof arr[0]:    20
f:    sizeof arr[0][0]: 4

尽管arr 是一个数组，但它在传递给f() 时会衰减为指向其第一个元素的指针，因此f() 中打印的大小是“错误的”。此外，在f() 中，arr[0] 的大小是数组arr[0] 的大小，它是“int 的数组 [5]”。它不是int * 的大小，因为“衰减”只发生在第一层，这就是为什么我们需要将f() 声明为采用指向正确大小数组的指针。

因此，正如我所说，只有满足上述两个条件，您最初所做的事情才会起作用。如果没有，您将需要按照其他人所说的去做：

memset(array, 0, m*n*sizeof array[0][0]);

最后，您发布的memset() 和for 循环在严格意义上并不等同。对于某些类型（例如指针和浮点值），可能存在（并且曾经存在过）“所有位为零”不等于零的编译器。不过，我怀疑您是否需要担心这一点。

Answer 2

使用 calloc 代替 malloc 。 calloc 会将所有字段初始化为 0。

int *a = (int *)calloc(n,size of(int)) ;

//a的所有单元格都被初始化为0

Answer 3

你可以试试这个

int array[20,30] = {{0}};

Answer 4

int array[N][M] = {0};

...至少在 GCC 4.8 中。

Answer 5

如果您真的非常着迷于速度（而不是可移植性），我认为绝对最快的方法是使用 SIMD 向量内在函数。例如在 Intel CPU 上，您可以使用这些 SSE2 指令：

__m128i _mm_setzero_si128 ();                   // Create a quadword with a value of 0.
void _mm_storeu_si128 (__m128i *p, __m128i a);  // Write a quadword to the specified address.

每条存储指令将一次性将四个 32 位整数设置为零。

p 必须是 16 字节对齐的，但是这个限制对速度也有好处，因为它有助于缓存。另一个限制是 p 必须指向 16 字节的倍数的分配大小，但这也很酷，因为它允许我们轻松展开循环。

将它放在一个循环中，并展开循环几次，你将拥有一个疯狂的快速初始化程序：

// Assumes int is 32-bits.
const int mr = roundUpToNearestMultiple(m, 4);      // This isn't the optimal modification of m and n, but done this way here for clarity.    
const int nr = roundUpToNearestMultiple(n, 4);    

int i = 0;
int array[mr][nr] __attribute__ ((aligned (16)));   // GCC directive.
__m128i* px = (__m128i*)array;
const int incr = s >> 2;                            // Unroll it 4 times.
const __m128i zero128 = _mm_setzero_si128();

for(i = 0; i < s; i += incr)
{
    _mm_storeu_si128(px++, zero128);
    _mm_storeu_si128(px++, zero128);
    _mm_storeu_si128(px++, zero128);
    _mm_storeu_si128(px++, zero128);
}

还有一个_mm_storeu 的变体可以绕过缓存（即清零数组不会污染缓存），在某些情况下可以为您带来一些次要的性能优势。

在此处查看 SSE2 参考：http://msdn.microsoft.com/en-us/library/kcwz153a(v=vs.80).aspx

Answer 6

memset(array, 0, sizeof(int [n][n]));

Answer 7

我认为手动完成的最快方法是遵循代码。您可以将它的速度与 memset 函数进行比较，但应该不会更慢。

（如果您的数组类型与 int 不同，则更改 ptr 和 ptr1 指针的类型）

#define SIZE_X 100
#define SIZE_Y 100

int *ptr, *ptr1;
ptr = &array[0][0];
ptr1 = ptr + SIZE_X*SIZE_Y*sizeof(array[0][0]);

while(ptr < ptr1)
{
    *ptr++ = 0;
}

Answer 8

如果使用malloc 初始化数组，请改用calloc；它将免费将您的数组归零。 （显然与 memset 的性能相同，只是代码更少。）

Answer 9

memset(array, 0, sizeof(array[0][0]) * m * n);

其中m 和n 是二维数组的宽度和高度（在您的示例中，您有一个正方形二维数组，所以m == n）。

Answer 10

嗯，最快的方法就是完全不这样做。

我知道这听起来很奇怪，这是一些伪代码：

int array [][];
bool array_is_empty;


void ClearArray ()
{
   array_is_empty = true;
}

int ReadValue (int x, int y)
{
   return array_is_empty ? 0 : array [x][y];
}

void SetValue (int x, int y, int value)
{
   if (array_is_empty)
   {
      memset (array, 0, number of byte the array uses);
      array_is_empty = false;
   }
   array [x][y] = value;
}

实际上，它仍在清除数组，但仅在向数组写入内容时。这不是一个很大的优势。但是，如果二维数组是使用四叉树（不是动态思维）或数据行集合来实现的，那么您可以本地化布尔标志的效果，但您需要更多标志。在四叉树中为根节点设置空标志，在行数组中为每一行设置标志。

这会导致“为什么要反复将大型二维数组归零”的问题？数组是干什么用的？有没有办法改变代码使数组不需要归零？

例如，如果您有：

clear array
for each set of data
  for each element in data set
    array += element 

也就是说，将其用作累积缓冲区，然后像这样更改它会不断提高性能：

 for set 0 and set 1
   for each element in each set
     array = element1 + element2

 for remaining data sets
   for each element in data set
     array += element 

这不需要清除数组，但仍然有效。这将比清除阵列快得多。就像我说的，最快的方法是一开始就不做。

Answer 11

这是因为 sizeof(array) 为您提供了 array 指向的对象的分配大小。 （array 只是指向多维数组第一行的指针）。但是，您分配了 j 个大小为 i 的数组。因此，您需要将 sizeof(array) 返回的一行的大小乘以您分配的行数，例如：

bzero(array, sizeof(array) * j);

还要注意 sizeof(array) 仅适用于静态分配的数组。对于动态分配的数组，您将编写

size_t arrayByteSize = sizeof(int) * i * j; 
int *array = malloc(array2dByteSite);
bzero(array, arrayByteSize);

Answer 12

你的二维数组是如何声明的？

如果是这样的：

int arr[20][30];

您可以通过以下方式将其归零：

memset(arr, sizeof(int)*20*30);