Reassigning to a pointer variable after freeing it

Question

Is this legal to do? Can you assign ptr to something after it has been freed?

int * ptr = (int*) malloc(sizeof(int));
free(ptr);
ptr = (int *) malloc(sizeof(int));

Answer 1

You aren't reassigning the pointer after freeing it, you're just reusing the ptr variable. This is perfectly fine.

Answer 2

First of all, as I mentioned in the comments, please see this discussion on why not to cast the return value of malloc() and family in C..

That said, yes, the (re)-assignment is fine here.

Actually, the question wording

Can you assign ptr to something after it has been freed?

should read

Can you assign ptr with something after it has been freed?

Guess what, the assignment without free-ing is also legal as per C, but it will create a memory leak as a side effect as the variable ptr was holding the return value of a memory allocator function and you need to free the memory once you're done using it. If, you re-assign the pointer without keeping a copy of the pointer, you'll lose the access to the memory allocated by allocator function and will have no ways to free() it.

In case the pointer was holding an address of statically allocated variable, you don't get to (nned to) free it and direct re-assignment is perfectly fine. think of this below snippet.

int x = 5, y = 10;
int * p = &x;
//do something with p
p = &y; //this is fine, just a re-assignment.

Answer 3

Yes. it is a valid in C language.

Related stack overflow question for more information: Reusing freed pointers in C

According to cwe.mitre.org:

In this scenario, the memory in question is allocated to another pointer validly at some point after it has been freed. The original pointer to the freed memory is used again and points to somewhere within the new allocation. As the data is changed, it corrupts the validly used memory; this induces undefined behavior in the process.

Answer 4

Is this legal to do? Can you assign ptr to something after it has been freed?

Yes, this is legal. ptr can be reassigned as many times as you want. Freeing that pointer is not necessary for reassigning it, for example

int * ptr = malloc(sizeof(int));
int *temp_ptr = ptr;         // temp_ptr is pointing to the location ptr is pointing
ptr = malloc(sizeof(int));   // ptr points to new location.

Note that you should not cast the return value of malloc.

Answer 5

Can you assign ptr to something after it has been freed?

int * ptr = (int*) malloc(sizeof(int)); /* line 1 */
free(ptr); /* line 2 */
ptr = (int *) malloc(sizeof(int)); /* line 3 */

Taking your question as:

"Is it legal to assign the address of freshly, dynamically allocated memory to a pointer (line 3), after the memory this pointer pointed to from a previous dynamical allocation (line 1) had been freed (line2)?"

Then this answer is yes.

---

Running line 3 would also be valid without having run line 2. Still, if not calling free() (line 2), the value assigned to ptr (line 1) is overwritten (line 3), and with this the possibility to call free() on ptr's initial value is lost, which in turn leaves the program with leaking exactly this memory allocated initially.

Answer 6

Yes you are assigning new memory on heap and its legal.

I would recommend you use realloc instead.

For the case when realloc() fails, from c11, chapter §7.22.3.5,

The realloc function returns ... a null pointer if the new object could not be allocated.

and

[....] If memory for the new object cannot be allocated, the old object is not deallocated and its value is unchanged.

The proper way of using realloc will be

ptr_new = realloc(ptr, sizeof(int)*2);
if (ptr_new == NULL)
{
    free(ptr);
}

Also please read why should i not cast return value of malloc.

Answer 7

Yes. It is perfectly legal. ptr is a standalone variable that continues to exist regardless of its contents. Nothing happens to the memory location where ptr is stored. There is nothing to prevent you from assigning you any value to it. The correctness of the memory allocation ( malloc / realloc etc) is a different story, but there is nothing wrong with reusing a variable (a memory location) to store the address of a memory location.

Answer 8

When you declare a pointer it will be allocated for it a memory location. That location can be reassigned.

If you reassign it after having assigned it a value with a malloc() call and before to free() it, this is a memory leak. After free() you can reassign it and no leak will happen, do not forget to free() it again.

In fact, the operating systems that are useful programs that never finish will reassign all the time some fixed pointers toward processes, free them when the process finishes, etc.

The programming in which assignments are not allowed is called functional programming.