How to zero out new memory after realloc

c, memory-management, null

Solution

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.

Problem

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

Original source