Valgrind的输出是什么意思？

Question

So I'm writing this C++ program and I've narrowed down my memory leaks by quite a bit thank to valgrind . But I still have a large chunk of leaks to go. But my valgrind output isn't making any sense:

9,512 (7,104 direct, 2,408 indirect) bytes in 148 blocks are definitely lost in loss record 4 of 4

==2638==    at 0x402B9B4: operator new(unsigned int) (in /usr/lib/valgrind
/vgpreload_memcheck-x86-linux.so)
==2638==    by 0x804C8AD: __gnu_cxx::new_allocator<std::vector<plate, std::allocator<plate> > >::allocate(unsigned int, void const*) (in /home/.../program)
==2638==    by 0x804C2FF: std::_Vector_base<std::vector<plate, std::allocator<plate> >, std::allocator<std::vector<plate, std::allocator<plate> > > >::_M_allocate(unsigned int) (in /home/.../program)
==2638==    by 0x804B7F7: std::vector<std::vector<plate, std::allocator<plate> >, std::allocator<std::vector<plate, std::allocator<plate> > > >::_M_insert_aux(__gnu_cxx::__normal_iterator<std::vector<plate, std::allocator<plate> >*, std::vector<std::vector<plate, std::allocator<plate> >, std::allocator<std::vector<plate, std::allocator<plate> > > > >, std::vector<plate, std::allocator<plate> > const&) (in /home/.../program)
==2638==    by 0x804AF48: std::vector<std::vector<plate, std::allocator<plate> >, std::allocator<std::vector<plate, std::allocator<plate> > > >::push_back(std::vector<plate, std::allocator<plate> > const&) (in /home/.../program)
==2638==    by 0x804A57C: hanoi_object::hanoi_object(hanoi_object const&) (in /home/.../program)
==2638==    by 0x804A6C9: hanoi_object::getMoves() const (in /home/.../program)
==2638==    by 0x8048FE1: Solver::solve(std::Config*, std::Config*) (in /home/.../program)
==2638==    by 0x804A0D3: main (in /home/.../program)

Program abstract~ skip if you want.

My program is basically a rudimentary Hanoi puzzle solver using a breadth first search algorithm to solve. Now, I represent the puzzle itself by a double vector of plate objects ( vector< vector< plate > > ), where plate is but a simple class that holds one integer value, the weight or size of the disk. A class called hanoi_object is responsible for collecting, representing, moving and maintaining these objects. A solver class will later allocate various hanoi_objects on the heap and delete it if it's not what we're looking for.

According to valgrind it looks like it's having issues with my double vector of plate objects. But why? It's a class that contains a simple int value and I never allocate any plate objects on the heap. Does allocating the handler/controller object ( hanoi_object ) on the heap also allocate my double vector plate object or something?

Here's the destructor:

hanoi_object::~hanoi_object(){
    for(int i=0; i<pegs_.size(); i++){
        pegs_[i].clear();
    }
    pegs_.clear();
}

And the copy constructor:

hanoi_object::hanoi_object(const hanoi_object& hanoi_object){
    for(int i = 0; i < hanoi_object.pegs_.size(); i++){
        vector<plate> PL;
        for(int j = 0; j < hanoi_object.pegs_[i].size(); j++){
            plate somePlate(hanoi_object.pegs_[i][j].getWeight());
            PL.push_back(somePlate);
        }
        pegs_.push_back(PL);
    }
}

All allocations in the hanoi_object are in other functions and I've triple checked to make sure that those are either deleted or passed to another class.

Answer 1

It appears that your copy constructor hanoi_object::hanoi_object(hanoi_object const&) is allocating something (probably with new ) which your destructor is not freeing (with delete ). It looks like it is the double vector of plate s. Much more than that, we can't say without seeing the code for the copy constructor and the destructor.

---

The boundary between 'system' and 'user' functions in the trace is at:

• std::vector<std::vector<plate, std::allocator<plate> >, std::allocator<std::vector<plate, std::allocator<plate> > > > ::push_back(std::vector<plate, std::allocator<plate> > const&)
• hanoi_object::hanoi_object(hanoi_object const&)

This indicates to me that one of the two push_back calls in the copy constructor is doing the damage. Given the type information, I think it is the second such call:

pegs_.push_back(PL);

Formally, we can't tell from the information given whether pegs_ is a global variable or a class member (yes, I know; it is probably a class member, but we can't be sure since you've not shown us even an outline of the class definition).

In the destructor, you clear the pegs_ variable. This removes and destroys all the elements in the vector; it does not free the vector itself.

Answer 2

I never allocate any plate objects on the heap.

vector allocates on the heap.

Just trust valgrind. The line he complaining about allocates memory which was never freed.