Freeing memory before calling realloc()

Question

there is some confusion regarding my code below.

I allocate memory with malloc(), free it, then call realloc() with the same pointer ptr as the parameter, but don't use the return address from realloc.

This code compiles and runs fine printing the expected string. I didn't expect it to as ptr was previously freed.

If I however assign the return address from realloc() to ptr instead, which is commented out, there are of course runtime errors as expected , as ptr will be NULL.

Why does it work if I just pass the previously freed ptr as a parameter. It obviously allocates the memory again? Thanks in advance.

NOTE: This code was wrote intentionally just to try and understand what is happening in the background. De-referencing a dangling pointer etc. of course is not recommended.

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

int main()
{
    char* ptr;
    ptr = (char*)malloc(20);

    strcpy(ptr, "Hello");

    printf("Address before free : %d\n", ptr);
    printf("%s\n", ptr);

    free (ptr);

    printf("Address after free  : %d\n", ptr);
    printf("%s\n", ptr);

    realloc(ptr, 30);

    //ptr = realloc(ptr, 30); // causes runtime problem as expected

    strcpy(ptr, "Hello");

    printf("Address after realloc  : %d\n", ptr);
    printf("%s\n", ptr);

    return 0;
}

Answer 1

For realloc(), specifically, quoting the C11 standard, chapter §7.22.3.5

If ptr is a null pointer, the realloc function behaves like the malloc function for the specified size. Otherwise, if ptr does not match a pointer earlier returned by a memory management function, or if the space has been deallocated by a call to the free or realloc function, the behavior is undefined. [....]

That said, in this case, you've invoked undefined behavior well before that, by saying

printf("Address after free  : %d\n", ptr);
printf("%s\n", ptr);

where the mistakes are

• %p is the required format specifier for a pointer, with the argumet casted to void *, not %d
• attempt to use free()-d memory

which, both , individually and alone is sufficient to invoke UB.

---

Bottom line: Don't try to free() a pointer before passing it to realloc(), it will be taken care on it's own.

Answer 2

The function called realloc() will reallocate the area of memory provided that it was previously allocated with malloc() calloc(), or realloc and not yet freed with making a call to free(). If free() is called on a piece of memory prior to realloc() will result in undefined behavior. Don't use realloc() with memory that has already been freed.

Best Regards!

Answer 3

Correct and demonstrative version of your program:

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

int main()
{
    char* ptr;
    ptr = malloc(20);

    strcpy(ptr, "Hello");

    printf("Address : %p\n", (void*)ptr);
    printf("%s\n", ptr);

    ptr = realloc(ptr, 30);   // expand the memory pointed by ptr
                              // from 20 to 30 bytes.

    printf("Address after realloc  : %p\n", (void*)ptr);  // address most likely different
    printf("%s\n", ptr);                           // displays still "Hello"
                                                   // as realloc preserves memory content

    free(ptr);     // eventually free what has been allocated previously
    return 0;
}

Sample output:

Address : 00767BC8
Hello
Address after realloc  : 00768C38
Hello

BTW: the addresses before and after realloc could potentially be the same, depending on the implementation.

Try to realloc less memory (e.g. 18), and the addresses will most likely be the same, but this is still implementation dependent.

Answer 4

ptr = realloc(ptr, 30);

This is bad. What if realloc fails, e.g. not enough memory and returns zero, then you loose your original pointer and you've got memory leak right there