c - Instead of just using free() and having the pointer pointing some new block, how to really empty the previously-pointed-at memory block?

Question

I am trying to free dynamically allocated memory using free(), but I found that what it does is to have the argument pointer point to some new location, and leaving the previously-pointed-at location as it was, the memory is not cleared. And if I use malloc again, the pointer may point to this messy block, and it's already filled with garbage, which is really annoying..

I'm kinda new to C and I think delete[] in c++ doesn't have this problem. Any advise?

Thanks

Answer 1

By free the memory is just released from use. It is released from being allocated to you. it is not explicitly cleared. Some old contents might be present at those memory locations. To avoid this, there are two solutions.

Solution 1:

You will need to do a memset after allocating memory using malloc.

Code Example:

unsigned int len = 20; // len is the length of boo
char* bar = 0;
bar= (char *)malloc(len);

memset(bar, 0, len);

Solution 2:

Or use, calloc() which initiliazes memory to 0 by default.

Code Example:

  int *pData = 0;
  int i = 10;
  pData = (int*) calloc (i,sizeof(int));

---

I think delete[] in c++ doesn't have this problem.

No
It behaves exactly this same way. Unless you explicitly set the pointer to 0 the delete'd pointer will not be pointing to 0. So do always set the pointer to 0 after you delete it.

---

When should you use malloc over calloc or vice versa?

Since calloc sets the allocated memory to 0 this may take a little time, so you may probably want to use malloc() if that performance is an issue.(Ofcourse One most profile their usage to see if this really is a problem)

If initializing the memory is more important, use calloc() as it does that explicitly for you.

Also, some OS like Linux have an Lazy Allocation memory model wherein the returned memory address is a virtual address and the actual allocation only happens at run-time. The OS assumes that it will be able to provide this allocation at Run-Time.

The memory allocated by malloc is not backed by real memory until the program actually touches it.

While, since calloc initializes the memory to 0 you can be assured that the OS has already backed the allocation with actual RAM (or swap).

---

How about realloc?

Yes, similar behavior to malloc.
Excerpt From the documentation:

void * realloc ( void * ptr, size_t size );

Reallocate memory block

The size of the memory block pointed to by the ptr parameter is changed to the size bytes, expanding or reducing the amount of memory available in the block.

The function may move the memory block to a new location, in which case the new location is returned. The content of the memory block is preserved up to the lesser of the new and old sizes, even if the block is moved.If the new size is larger, the value of the newly allocated portion is indeterminate.

In case that ptr is NULL, the function behaves exactly as malloc, assigning a new block of size bytes and returning a pointer to the beginning of it.

In case that the size is 0, the memory previously allocated in ptr is deallocated as if a call to free was made, and a NULL pointer is returned.