Why am I leaking memory here (depth first search) c++? - c++

Question

int Solver::negamax(Position* pos,int alpha,int beta, int color, int depth ) {
if(depth==0 || is_final(pos)){
return evaluate(pos);
}
else{
vector < Position* > moves = generate_moves(pos->get_board());
vector < Position* >::iterator move;
int min = 99999;
for(move = moves.begin(); move < moves.end(); move++){
int val = negamax(*move,alpha, beta, -color, depth - 1 );
if(val <= min){
min = val;
delete best;
best = NULL;
best = (*move)->get_board();
}
else{
delete *move; //So this isnt cleaning up?
*move = NULL;
}
}
min = -min;
return min;
}
}
vector < Position* > TakeAwaySolver::generate_moves(Board *brd){
TakeAwayBoard *board = static_cast<TakeAwayBoard*>(brd);
vector < Position* > moves;
if(board->get_data() >= 3){
TakeAwayBoard *b = new TakeAwayBoard(board->get_data() - 3);
Position* p = new Position(b);
moves.push_back(p);
}
if(board->get_data() >= 2){
TakeAwayBoard *b = new TakeAwayBoard(board->get_data() - 2);
Position* p = new Position(b);
moves.push_back(p);
}
TakeAwayBoard *b = new TakeAwayBoard(board->get_data() - 1);
Position* p = new Position(b);
moves.push_back(p);
return moves;
}
I valgrinded my program and I'm apparently leaking memory. It seems that I'm deleting all unused objects, but perhaps I'm not understanding something. generate_moves() does allocate memory for each of the objects being pushed in. Evaluate returns 1. Does it seem possible that I'm leaking memory in any location?

Answer 1

You have an if/else in which *move is only deleted in one of the paths. I'd check there.
for(move = moves.begin(); move < moves.end(); move++){
int val = negamax(*move,alpha, beta, -color, depth - 1 );
if(val <= min){
min = val;
delete best;
best = NULL;
best = (*move)->get_board();
//best is deleted, but *move is not
}
else{
delete *move;
*move = NULL;
}
}

Answer 2

A std::vector<position *> container will not automatically delete the inserted elements when it is destroyed. Make it a std::vector<x<position *> > where x is some suitable smart pointer template, like auto_ptr.
If you don't want to do that, then the next best thing is to wrap the vector in a class whose destructor iterates over the vector and calls delete on every pointer.
I.e. this is a memory leak:
{
std::vector<int *> vec;
vec.push_back(new int[3]);
// vec goes out of scope
}
Sure, the vector cleans itself up! It deletes its internal array, etc. But it does nothing with the new int[3] that we allocated and put into the vector.

Answer 3

It seems to me that you never clear the 'minimum' positions.
You store a pointer to the board in best, and take care to clear that when you replace it with a better minimum, and in case the move isn't a minimum so far, you properly clean it up, but you never clean the actual position pointer in case it's a minimum.
As a side note, this is redundant:
best = NULL;
best = (*move)->get_board();