重新分配后如何将新内存清零

Question

调用 realloc 后将新内存清零同时保持最初分配的内存完整的最佳方法是什么？

#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <stdio.h>

size_t COLORCOUNT = 4;

typedef struct rgb_t {
    int r;
    int g;
    int b;
} rgb_t;

rgb_t** colors;

void addColor(size_t i, int r, int g, int b) {
    rgb_t* color;
    if (i >= COLORCOUNT) {
        // new memory wont be NULL
        colors = realloc(colors, sizeof(rgb_t*) * i);
       //something messy like this...
        //memset(colors[COLORCOUNT-1],0 ,sizeof(rgb_t*) * (i - COLORCOUNT - 1));

         // ...or just do this (EDIT)
        for (j=COLORCOUNT; j<i; j++) {
            colors[j] = NULL;
        }

        COLORCOUNT = i;
    }

    color = malloc(sizeof(rgb_t));
    color->r = r;
    color->g = g;
    color->b = b;

    colors[i] = color;
}

void freeColors() {
    size_t i;
    for (i=0; i<COLORCOUNT; i++) {
        printf("%x\n", colors[i]);
        // can't do this if memory isn't NULL
       // if (colors[i])
         //   free(colors[i]);

    }
}


int main() {
    colors = malloc(sizeof(rgb_t*) * COLORCOUNT);
    memset(colors,0,sizeof(rgb_t*) * COLORCOUNT);
    addColor(0, 255, 0, 0);
    addColor(3, 255, 255, 0);
    addColor(7, 0, 255, 0);


    freeColors();
    getchar();
}

Answer 1

没有办法将这个问题作为一般模式来解决。原因是为了知道缓冲区的哪一部分是新的，您需要知道旧缓冲区有多长。在 C 中不可能确定这一点，因此无法找到通用解决方案。

不过你可以像这样写一个包装器

void* realloc_zero(void* pBuffer, size_t oldSize, size_t newSize) {
  void* pNew = realloc(pBuffer, newSize);
  if ( newSize > oldSize && pNew ) {
    size_t diff = newSize - oldSize;
    void* pStart = ((char*)pNew) + oldSize;
    memset(pStart, 0, diff);
  }
  return pNew;
}

Answer 2

可能不需要执行memset：在使用稍后有效的内容进行设置之前，您可能不会使用colors[k]。例如，您的代码将 colors[i] 设置为新分配的 color 指针，因此您不需要设置 colors[i]为NULL。

但是，即使您想“将其清零，这样一切都很好”，或者确实需要新指针为 NULL：C 标准并不保证所有位为零都是 null指针常量（即 NULL），因此 memset() 无论如何都不是正确的解决方案。

您可以做的唯一可移植的事情是在循环中将每个指针设置为 NULL：

size_t k;
for (k=COLORCOUNT; k < i+1; ++k) /* see below for why i+1 */
    colors[k] = NULL;

您的主要问题是您的 realloc() 调用是错误的。 realloc() 返回一个指向已调整大小的内存的指针，它不会（必然）就地调整其大小。

因此，您应该这样做：

/* i+1 because you later assign to colors[i] */
rgb_t **tmp = realloc(colors, (i+1) * sizeof *tmp);
if (tmp != NULL) {
    /* realloc succeeded, can't use colors anymore */
    colors = tmp;
} else {
    /* realloc failed, colors is still valid */
}

如果您确实想知道 memset() 调用应该是什么，则需要将从 colors+COLORCOUNT 开始的内存设置为零，并且将 i+1-COLORCOUNT 成员设置为零：

memset(colors+COLORCOUNT, 0, (i+1-COLORCOUNT) * sizeof *colors);

但正如我上面所说，所有字节为零并不能保证都是 NULL 指针，因此您的 memset() 无论如何都是没用的。如果您想要 NULL 指针，则必须使用循环。

Answer 3

首先，realloc 可能会失败，因此您需要检查 NULL。其次，没有更好的方法将内存清零：只需从旧缓冲区的末尾到较大缓冲区的末尾进行 memset 即可。

Answer 4

编写您自己的函数，例如 reallocz，它接受当前大小作为参数，并为您调用 realloc 和 memset。它真的不会比你已经拥有的更好......毕竟它是 C。

Answer 5

在 Linux 上，现在有 size_t malloc_usable_size (void *ptr)，由 提供。可以在 https://linux.die.net/man/3/malloc_usable_size。

这意味着您现在可以为 realloc(3) 编写通用包装器：

void *realloc_zero(void *oldptr, size_t reqsize) {
  size_t oldsize = malloc_usable_size(ptr);
  void *newptr;
  if ((newptr = realloc(ptr, reqsize)) == NULL) {
    return NULL;
  }
  size_t newsize = malloc_usable_size(newptr);
  if (oldsize < newsize) {
    memset((char *) newptr + oldsize, 0, newsize - oldsize);
  }
  return newptr;
}

请注意，malloc_usable_pointer(3) 不一定返回与您调用 calloc(3) 时使用的字节数相同 - 例如，

void *p = calloc(8, 1);
printf("%zu\n", malloc_usable_pointer(p));

在我的 Linux 计算机上打印 16。
另请注意，您应该仅在通过 calloc(3) 获得的堆分配上调用上述 realloc_zero()，因为 calloc() 将对malloc_usable_pointer()报告的任何额外字节进行零初始化。