Memory leak when storing pointers into vector

Question

I have read multiple similar questions on the same topic that have been asked, but I was not able to resolve my issue by following them.

I want to store pointers in a vector, but I see a memory leak. My code is as follows.

#include <iostream>
#include <vector>
#include <memory>

class Base 
{
    public:
       virtual ~Base() {}
};

class Derived : public Base {};

std::vector<std::unique_ptr<Base>> bv;

int main()
{
    for (int i = 0; i < 10; i++)
       bv.emplace_back(std::make_unique<Base>(Derived()));

    bv.clear();

    return 0;
}

Valgrind reports: "still reachable: 72,704 bytes in 1 blocks". I have the same issue if I don't use unique_ptr, and just use bv.emplace_back(new Derived);, and delete the pointers explicitly from the vector. What is causing the leak?

These bytes are probably coming from `bv` vector itself. Try moving it into `main` to make sure its content is deleted. — Sergey Kalinichenko, Aug 02 '17 at 19:23
Does the behavior change when you move the vector into `main()`? — cmaster - reinstate monica, Aug 02 '17 at 19:32
@dasblinkenlight no idea. I just find it suprising for the vector allocate 72K in this scenario. There are only 10 elements, and each element is (supposedly) 8bytes. — SergeyA, Aug 02 '17 at 19:33
I cannot reproduce the problem on my machine (Debian 9, `g++`). Must be some implementation specific issue. The 72k looks rather large, it's a size that's most certainly not associated with the code you've shown. — cmaster - reinstate monica, Aug 02 '17 at 19:35
I'm baffled by the 72K thing too (could it be that valgrind is misreporting?), my system is Debian 9, g++ 6.3.0. There is no change when I move `bv` to `main()`. — Sayan, Aug 02 '17 at 20:11
@Sayan memory gets requested from the system by chunks optimized for the common case. In a typical program you would use much more memory then in your example. — Sergei, Aug 02 '17 at 20:22

Sergei · Accepted Answer · 2017-08-02T22:24:11.673

5

Looks like you actually store instances of Base class. Derived() creates an object on the stack and then make_unique passes it to the constructor of Base. This is object slicing. This won't explain the leak but indicates the code may not do what you expect.

ADDITION: DELETED: free() doesn't always return memory back to the system. Libc will keep this memory for future malloc(). This probably explains your observation.

I agree with @cmaster's comment below. Valgrind does keep track of malloc/free. After a bit of research I found another question on stackoverflow which explains the observation.

include iostream

"Many implementations of the C++ standard libraries use their own memory pool allocators." They just don't free their memory.

More details: Valgrind: Memory still reachable with trivial program using <iostream>

edited Aug 02 '17 at 22:24

answered Aug 02 '17 at 19:39

Sergei

508
7
13

I want to store instances of Base class. In my real application, the derived class is templated, and since I need to access it later (when I won't know the template), I store a non-templated pointer to base class. – Sayan Aug 02 '17 at 20:19
1

@Sayan my comment was based on your example. It's hard to see why you would want to have object slicing in your code. – Sergei Aug 02 '17 at 20:24
Yes, I agree with you. – Sayan Aug 02 '17 at 20:28
3

`free()` may not return memory to the system, but `valgrind` keeps track on what is returned from `malloc()` and what is passed into `free()` anyway. After all, valgrind actually runs the program on a simulated CPU, it's not just listening on the syscalls as `strace` does. So, the implementation details are definitely not the answer to this question. – cmaster - reinstate monica Aug 02 '17 at 21:19

Memory leak when storing pointers into vector

1 Answers1