如何归零后的realloc新内存 [英] How to zero out new memory after realloc

问题描述

什么是调用realloc的同时保持初始分配的内存完好无损后零出新的记忆的最佳方式？

 的#include＆LT;＆stdlib.h中GT;
＃包括LT＆;＆ASSERT.H GT;
＃包括LT＆;＆string.h中GT;
＃包括LT＆;＆stdio.h中GT;为size_t COLORCOUNT = 4;typedef结构rgb_t {
    INT R;
    INT克;
    INT B：
} rgb_t;rgb_t **颜色;无效addColor（为size_t我，INT R，诠释克，INT B）{
    rgb_t *色;
    如果（ⅰ＆GT = COLORCOUNT）{
        //新的内存不会是NULL
        颜色= realloc的（颜色，sizeof的（rgb_t *）* I）;
       //凌乱的东西像这样...
        // memset的（颜色[COLORCOUNT-1]，0，sizeof的（rgb_t *）*（I  -  COLORCOUNT  -  1））;         // ...或只是做到这一点（编辑）
        为（J = COLORCOUNT; J＆LT; I; J ++）{
            色彩[J] = NULL;
        }        COLORCOUNT = I;
    }    颜色=的malloc（sizeof的（rgb_t））;
    color-＆GT; R = R;
    color-＆GT; G =克;
    color-＆GT; B =;    颜色由[i] =颜色;
}无效freeColors（）{
    为size_t我;
    对于（i = 0; I＆LT; COLORCOUNT;我++）{
        的printf（％X \\ n，颜色[I]）;
        //不能做到这一点，如果内存是不是NULL
       //如果（颜色[I]）
         //自由（颜色[I]）;    }
}
诠释主（）{
    颜色=的malloc（sizeof的（rgb_t *）* COLORCOUNT）;
    memset的（颜色，0，sizeof的（rgb_t *）* COLORCOUNT）;
    addColor（0，255，0，0）;
    addColor（3，255，255，0）;
    addColor（7,0，255，0）;
    freeColors（）;
    的getchar（）;
}
 

解决方案

有可能是没有必要做 memset的：您可能没有使用颜色[K] 与后来的一些有效的设置它。例如，您的code组颜色[I] 来一个新分配的颜色指针，所以你没'吨需要设置颜色[I] 到 NULL 。

不过，即使你想零出来，所以一切是好的，还是真的需要新的指针是 NULL ：C标准不保证所有位归零是空指针常数（即 NULL ），所以 memset的（）不是反正合适的解决方案。

你唯一可以做的便携式就是设置每个指针 NULL 在一个循环：

 为size_t K表;
对于（K = COLORCOUNT; K＆LT;我+ 1; + K）/ *请参阅下面我为什么+ 1 * /
    颜色[K] = NULL;
 

您首要的问题是，你的的realloc（）电话是错误的。 的realloc（）返回一个指针大小的内存，它不（一定）就地调整它的大小。

所以，你应该做的：

  / * I + 1，因为你以后分配给颜色[I] * /
rgb_t ** TMP = realloc的（颜色，第（i + 1）* sizeof的* TMP）;
如果（TMP！= NULL）{
    / * realloc的成功，不能用的颜色了* /
    颜色= tmp目录;
}其他{
    / * realloc的失败，颜色仍然是有效的* /
}
 

如果你真的想知道 memset的（）通话应该是什么，你需要设置为零的存储器中，起始颜色+ COLORCOUNT ，并设定第i + 1 COLORCOUNT 成员为零：

  memset的（色彩+ COLORCOUNT，0，（第i + 1 COLORCOUNT）* * sizeof的颜色）;
 

但正如我上面所说的，所有字节零不能保证是一个 NULL 指针，所以你的 memset的（）也没用呢。你如果想 NULL 指针使用循环。

What is the best way to zero out new memory after calling realloc while keeping the initially allocated memory intact?

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

解决方案

There is probably no need to do the memset: you may not be using colors[k] before setting it with something valid later. For example, your code sets colors[i] to a newly allocated color pointer, so you didn't need to set colors[i] to NULL.

But, even if you wanted to "zero it out so everything is nice", or really need the new pointers to be NULL: the C standard doesn't guarantee that all-bits-zero is the null pointer constant (i.e., NULL), so memset() isn't the right solution anyway.

The only portable thing you can do is to set each pointer to NULL in a loop:

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

Your primary problem is that your realloc() call is wrong. realloc() returns a pointer to the resized memory, it doesn't (necessarily) resize it in-place.

So, you should do:

/* 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 */
}

If you really want to know what the memset() call should be, you need to set to zero the memory starting at colors+COLORCOUNT, and set i+1-COLORCOUNT members to zero:

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

But as I said above, all bytes zero is not guaranteed to be a NULL pointer, so your memset() is useless anyway. You have to use a loop if you want NULL pointers.

这篇关于如何归零后的realloc新内存的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！