Can realloc potentially cause a memory leak?

[Jeff Rodriguez]

If you realloc, and the new memory has a different address, what happens at the
old address? Is that memory basically free()'d, or do you need to keep track of
address changes and manually free() ?

Jeff

 

[Artie Gold]

If you realloc, and the new memory has a different address, what happens
at the old address? Is that memory basically free()'d, or do you need to
keep track of address changes and manually free() ?

It is free()-ed.

HTH,
--ag

 

[Morris Dovey]

If you realloc, and the new memory has a different address, what happens
at the old address? Is that memory basically free()'d, or do you need to
keep track of address changes and manually free() ?

Jeff...

It doesn't cause a memory leak. It works to consider that memory
freed for re-use; but the actual (under the covers) disposition
is up to the implementation.

 

[Mac]

If you realloc, and the new memory has a different address, what happens at the
old address? Is that memory basically free()'d, or do you need to keep track of
address changes and manually free() ?

Jeff

In the case you seem to be discussing, the memory is effectively freed,
and you MUST not free it.

Misuse of realloc CAN cause a memory leak, but only when allocation fails.

Here's an example:


#include <stdlib.h>
....
char *foo;
int buf_size = 1;
....

foo = malloc(buf_size);
....

foo = realloc(foo, buf_size *= 2);

Here, if realloc fails, the memory previously pointed to by foo will still
be claimed, but you will have lost your only pointer to it, because
realloc returns NULL on failure. This is a memory leak.

HTH

Mac
--

 

[Derk Gwen]

# If you realloc, and the new memory has a different address, what happens at the
# old address? Is that memory basically free()'d, or do you need to keep track of
# address changes and manually free() ?

If the returned address is different from the input address, the input
address is no longer valid, as if it were passed to free; it can no longer
be safely freed, reallocked, or used to access memory. What actually happens
is implementation dependent.