Memory leak c++ list of array

Question

We have code like this:

  void main(){
  std::list<int *> ll;
  for(int i=0;i<100;i++)
   {
      int *a = new int[10000];
      ll.push_back(a);
   }
  for(int *b : ll)
  {
     delete [] b;
  }  
 ll.clear();

}

But the memory not free? Why? When run this code work correctly:

void main(){
 for(int i=0;i<100;i++)
 {
     int *a = new int[10000];
     delete [] a;
 }
}

I monitor memory with top command in linux and system monitoring, so in first code in first for the memory was going up and after that i expect that in last for the app free the memory but not free memory.

Probably because of the use of `valgrind` or some other tool? — Nepho, Nov 14 '17 at 12:15
Why are you allocating memory with `new[]`? Why not a list of `std::vector`? And is `std::list` really appropriate here? — Some programmer dude, Nov 14 '17 at 12:16
*How* do you "monitor memory?" Do you mean usage from the OS point of view? Memory freed by the runtime does not necessarily go straight back to the OS, but is still freed correctly from the runtime's perspective. — Angew is no longer proud of SO, Nov 14 '17 at 12:16
@Nepho i monitor, after first for the memory allocated but in last for not free then — Ebrahim Abdollahian, Nov 14 '17 at 12:17
@Angew i write some block of this code, every time memory was going up like back block — Ebrahim Abdollahian, Nov 14 '17 at 12:20
Just because you `delete` (or `delete[]`) something doesn't mean the now unallocated pages are actually removed from the process memory map. The code you show is correct. — Some programmer dude, Nov 14 '17 at 12:20
@Someprogrammerdude and how can i check my memory leak finally?! — Ebrahim Abdollahian, Nov 14 '17 at 12:22
@ebigood It's **not** a leak. The memory is not leaked, it *is* free, it's just not returned to the OS (yet). I believe [this question](https://stackoverflow.com/q/1119134/1782465) explains in detail. — Angew is no longer proud of SO, Nov 14 '17 at 12:23
Use tools such a [Valgrind](http://valgrind.org/) or similar. — Some programmer dude, Nov 14 '17 at 12:26
Possible duplicate of [Memory usage isn't decreasing when using free?](https://stackoverflow.com/questions/1556014/memory-usage-isnt-decreasing-when-using-free) — Tadeusz Kopec for Ukraine, Nov 14 '17 at 12:36
Please [edit] your question to show us what kind of debugging you've done. I expect you to have run your [mcve] within Valgrind or a similar checker, and to have investigated with a debugger such as GDB, for example. Ensure you've enabled a full set of compiler warnings, too. What did the tools tell you, and what information are they missing? And read Eric Lippert's [How to debug small programs](https://ericlippert.com/2014/03/05/how-to-debug-small-programs/). — Toby Speight, Nov 14 '17 at 13:16
Your code is incomplete; in particular, it seems to be missing a `main()` function and at least one `#include`. Please [edit] your code so it's a [mcve] of your problem, then we can try to reproduce and solve it. You should also read [ask]. — Toby Speight, Nov 14 '17 at 13:17

score 4 · Answer 1 · answered Nov 14 '17 at 12:27

[I monitor memory] in linux with top command and system monitoring

This approach will not give you an accurate result. Linux top command tells you how much memory the process holds, which includes the memory the allocator requested from OS. top does not know how much of this memory has been given to your program by the allocator, and how much is kept for giving to your program in the future.

In order to check your program for memory leaks and other memory-related errors use a memory profiling tool, such as valgrind. The profiler would detect memory leaks, and inform you of the places in your program that allocated blocks of memory which were not returned back to the allocator.

Note: The reason your other code appears to work is that the allocator needs a lot less memory, because the same chunk of memory gets allocated and de-allocated repeatedly in the loop.

So if i write two block code like above, the memory shouldn't allocate multiply? — Ebrahim Abdollahian, Nov 14 '17 at 12:38
@ebigood Correct. If the memory goes up then down then back up and then back down, you should not get past the "high watermark" at the peak of the first allocation. — Sergey Kalinichenko, Nov 14 '17 at 12:39

score 3 · Accepted Answer · answered Nov 14 '17 at 12:37

Like others said valgrind is the appropriate tool to use when tracking down memory leaks. Using valgrind on your program indeed shows that you have no memory leak:

    $ valgrind --leak-check=yes ./example 
==3945== Memcheck, a memory error detector
==3945== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==3945== Using Valgrind-3.10.1 and LibVEX; rerun with -h for copyright info
==3945== Command: ./example
==3945== 
==3945== 
==3945== HEAP SUMMARY:
==3945==     in use at exit: 0 bytes in 0 blocks
==3945==   total heap usage: 200 allocs, 200 frees, 4,002,400 bytes allocated
==3945== 
==3945== All heap blocks were freed -- no leaks are possible
==3945== 
==3945== For counts of detected and suppressed errors, rerun with: -v
==3945== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

Memory leak c++ list of array

2 Answers2