ownership of dynamic allocated memory

Question

What is the ownership of the dynamic allocated memory?

For example, in one program dynamic allocate memory like this:

int main()
{
   int * p = malloc(10 * sizeof(int));

   return 0;
}

1) if this program exit, then will the memory pointed by p be freed()? I think the answer will be, it will not be freed automatically.

2) if this program crash, then will the memory pointed by p be freed()?

This is environment/OS specific. Common Desktop/Server OS are very good at cleaning up after process termination, no matter how caused. — Martin James, Jun 03 '15 at 17:10
http://stackoverflow.com/questions/654754/what-really-happens-when-you-dont-free-after-malloc This will solve your problem to a large extent — Kunal Saini, Jun 03 '15 at 18:29

score 1 · Accepted Answer · edited May 23 '17 at 11:58

Memory Deallocation And Allocation

This link will help you to a great extent to solve your problem

The text below is from the above mentioned link:-

Just about every modern operating system will recover all the allocated memory space after a program exits. The only exception I can think of might be something like Palm OS where the program's static storage and runtime memory are pretty much the same thing, so not freeing might cause the program to take up more storage. (I'm only speculating here.)

So generally, there's no harm in it, except the runtime cost of having more storage than you need. Certainly in the example you give, you want to keep the memory for a variable that might be used until it's cleared.

However, it's considered good style to free memory as soon as you don't need it any more, and to free anything you still have around on program exit. It's more of an exercise in knowing what memory you're using, and thinking about whether you still need it. If you don't keep track, you might have memory leaks.

On the other hand, the similar admonition to close your files on exit has a much more concrete result - if you don't, the data you wrote to them might not get flushed, or if they're a temp file, they might not get deleted when you're done. Also, database handles should have their transactions committed and then closed when you're done with them. Similarly, if you're using an object oriented language like C++ or Objective C, not freeing an object when you're done with it will mean the destructor will never get called, and any resources the class is responsible might not get cleaned up.

Eric · Answer 2 · 2015-06-03T17:38:21.217

On linux, as long as the process terminated, all its memory will be freed, for reuse.

If your program runs long term(e.g shell or web server daemon), you should free every piece of memory by hand, otherwise, as time goes the limit of memory might be reached, and you can no long allocate memory.

If your program runs very short, you can leave the free job be done automatically when process terminate. Actually, free() itself also takes time, so this would save some machine resource, even though it's strongly not suggested.

free() every piece of memory by hand, also improve your maintainabiliy & readability of your project for long term.

score 0 · Answer 3 · answered Jun 03 '15 at 17:24

referred : GNU libc manual page for free()

So, according to libc manual

There is no point in freeing blocks at the end of a program, because all of the program’s space is given back to the system when the process terminates.

So even if your program crashed, memory will be freed and given back to system

ownership of dynamic allocated memory

3 Answers3