Thread: Free not working after malloc was used to allocate memory

Do not try access a pointer after you free() it - even in code like the definition of sb_massacre(). free() does not have to work in a particular way.

The memory is otherwise properly deallocated, but your massacre function does not update the pointer from the calling function, so it will still point to the old contents. If you want massacre() to change the calling function's pointer variable, you should do something like:

Code:

void sb_massacre(sb_string **target);

void sb_massacre(sb_string **target)
{
  if (target != NULL && *target != NULL)
  {
    free (*target);
    *target = NULL;
  }
}

// in a calling function such as main()...
sb_string *my_str;     
my_str = sb_init();
sb_massacre(&my_str);

After this, my_str will be NULL and further attempts to use it should segfault.

If you are curious why you could still read the old contents, please understand that free() does not have to disassociate pointers from their old contents; the memory has to be made available for reallocation only. You can try to access the old contents of a pointer, but you don't know what will happen. It could crash or not crash the program.

Note that free can be freely used on a null pointer, so if you were not printing stuff from within sb_massacre (sb_free or sb_destroy would probably be more common choices for the name) when the pointer from the caller is a null pointer, you could write:

Code:

void sb_massacre(sb_string **target)
{
    if (target)
    {
        free(*target);
        *target = NULL;
    }
}

Originally Posted by ehitam

Would the freed memory would be available for reallocation by other processes and programs too or only to the current program?

It depends on the impleemntation. malloc allocates memory inside some big memory chunk reserved by the process from the OS.

After it is freed memory manager can leave big chunk reserved for next malloc, or return it to the OS (if all parts of the chunk are already freed).