Any modern operating system will clean up everything after a process terminates, but it’s generally not a good practice to rely on this. It depends on the program you are writing. If it’s just a command line tool that runs and terminates quickly, you may not bother cleaning up. But be aware that it is … Read more
OK, there’s a fair deal of confusion explaining exactly what order the necessary free() calls have to be in, so I’ll try to clarify what people are trying to get at and why. Starting with the basics, to free up memory which has been allocated using malloc(), you simply call free() with exactly the pointer … Read more
It is undefined behaviour, so it is an error to deference freed pointer as strange things may (and will) happen. free() doesn’t change the value of the pointer so it keeps pointing to the heap in the process address space – that’s why you don’t get segfault, however it is not specified and in theory … Read more
Besides Klatchko’s correct point that the standard does not provide for it, real malloc/free implementations often allocate more space then you ask for. E.g. if you ask for 12 bytes it may provide 16 (see A Memory Allocator, which notes that 16 is a common size). So it doesn’t need to know you asked for … Read more
The easiest way to do it is to keep a linked list of free block. In malloc, if the list is not empty, you search for a block large enough to satisfy the request and return it. If the list is empty or if no such block can be found, you call sbrk to allocate … Read more
Several people have posted the right answer, but they keep deleting it for some reason. You need to cast it to a non-const pointer; free takes a void*, not a const void*: free((char*)str);
When you malloc memory, you’re given a pointer to some space, and when you free it, you’re giving it back to the system. Often, you can still access this memory, but using memory after you have freed it is VERY BAD. The exact behavior is undefined, but on most systems you can either continue to … Read more
The second one is way more important: re-using a freed pointer can be a subtle error. Your code keeps right on working, and then crashes for no clear reason because some seemingly unrelated code wrote in the memory that the re-used pointer happens to be pointing at. I once had to work on a really … Read more
Upon an object reaching the end of its lifetime, all pointers to it become indeterminate. This applies to block-scope variables and to malloced memory just the same. The applicable clause is, in C11, 6.2.4:2. The lifetime of an object is the portion of program execution during which storage is guaranteed to be reserved for it. … Read more
Your code is wrong. You are allocating space for a single pointer (malloc(sizeof(char*))), but no characters. You are overwriting your allocated space with all the strings, causing undefined behavior (in tihs particular case, corrupting malloc()‘s book-keeping data). You don’t need to allocate space for the pointer (res), it’s a local variable. You must allocate space … Read more