There are lots of ways in which malloc/free can store the size of the memory area. For example, it might be stored just before the area returned by malloc. Or it might be stored in a lookup table elsewhere. Or it might be stored implicitly: some areas might be reserved for specific sizes of allocations. … Read more
Your analogy is correct. The data in memory doesn’t disappear or anything like that; the values may indeed still be there after a free(), though attempting to read from freed memory is undefined behaviour.
If you do so you will run into undefined behavior. Never try that. Although new might be implemented through malloc() and delete might be implemented through free() there’s no guarantee that they are really implemented that way and also the user can overload new and delete at his discretion. You risk running into heap corruption. … Read more
You could define a new label that would free the resources and then you could GOTO it whenever your code fails. char* function() { char* retval = NULL; char* mem = get_memory(100); // first allocation if (!mem) goto out_error; struct binder* b = get_binder(‘regular binder’); // second allocation if (!b) goto out_error_mem; struct file* f … Read more
The POSIX interface of malloc is defined here. If you want to find out how the C library in GNU/Linux (glibc) implements malloc, go and get the source code from http://ftp.gnu.org/gnu/glibc/ or browse the git repository and look at the malloc/malloc.c file. There is also the base documentation of the Memory Allocator by Doug Lea … Read more
You can’t. The way to track this would be to assign the pointer to 0 or NULL after freeing it. However as Fred Larson mentioned, this does nothing to other pointers pointing to the same location. int* ptr = (int*)malloc(sizeof(int)); free(ptr); ptr = NULL;
You can certainly continue to use p after calling free(p) and nothing will stop you. However the results will be completely undefined and unpredictable. It works by luck only. This is a common programming error called “use after free” which works in many programs for literally years without “problems” — until it causes a problem. … Read more
That’s undefined behavior – never try it. Let’s see what happens when you try to free() an automatic variable. The heap manager will have to deduce how to take ownership of the memory block. To do so it will either have to use some separate structure that lists all allocated blocks and that is very … Read more
There’s no single definitive answer to your question. Firstly, the external behavior of a freed block will depend on whether it was released to the system or stored as a free block in the internal memory pool of the process or C runtime library. In modern OSes the memory “returned to the system” will become … Read more
For good reasons, virtually no memory allocator returns blocks to the OS Memory can only be removed from your program in units of pages, and even that is unlikely to be observed. calloc(3) and malloc(3) do interact with the kernel to get memory, if necessary. But very, very few implementations of free(3) ever return memory … Read more