C++ 为什么我在这里泄漏内存（深度优先搜索）c++；？ int-Solver:：negamax（位置*pos，int-alpha，int-beta，int-color，int-depth）{ 如果（深度==0 | |为最终值（位置））{ 退货评估（pos）； } 否则{ 向量moves=生成移动（pos->get_board（））； 向量：：迭代器移动； int-min=99999； 对于（move=moves.begin（）；move获取数据（）>=3）{ TakeAwayBoard*b=新的TakeAwayBoard（board->get_data（）-3）； 位置*p=新位置（b）； 移动。推回（p）； } 如果（线路板->获取数据（）>=2）{ 外卖板*b=新外卖板（板->获取数据（）-2）； 位置*p=新位置（b）； 移动。推回（p）； } 外卖板*b=新外卖板（板->获取数据（）-1）； 位置*p=新位置（b）； 移动。推回（p）； 回击动作；

}

---

我修改了我的程序，很明显我正在泄漏内存。看起来我正在删除所有未使用的对象，但可能我不了解一些东西。generate_moves（）是否为每个被推入的对象分配内存。Evaluate返回1。是否有可能在任何位置泄漏内存？

在我看来，您从未清除“最小”位置

您将指向电路板的指针存储在

best

中，当您用更好的最小值替换它时，请注意清除该指针，如果移动到目前为止不是最小值，请正确清理它，但如果实际位置指针是最小值，则永远不会清理它

作为旁注，这是多余的：

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;

---

在我看来，你永远不会清除“最低”位置

您将指向电路板的指针存储在

best

中，当您用更好的最小值替换它时，请注意清除该指针，如果移动到目前为止不是最小值，请正确清理它，但如果实际位置指针是最小值，则永远不会清理它

作为旁注，这是多余的：

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;

---

您有一个if/else，其中*move只在其中一个路径中被删除。我会在那里检查

    best = NULL;
    best = (*move)->get_board();

for（move=moves.begin（）；move

您有一个if/else，其中*move只在其中一个路径中被删除。我会在那里检查

    best = NULL;
    best = (*move)->get_board();

for（move=moves.begin（）；move

A

std:：vector

容器在销毁时不会自动删除插入的元素。将其设置为

std:：vector

，其中x是一些合适的智能指针模板，如

auto\u ptr

如果您不想这样做，那么下一个最好的方法是将该向量包装到一个类中，该类的析构函数迭代该向量，并在每个指针上调用delete

即，这是内存泄漏：

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;
          }
         }

{
std:：vec；
向量推回（新整数[3]）；
//vec超出范围
}

当然，向量会自己清理！它会删除它的内部数组，等等。但是它不会对

newint[3]执行任何操作

我们分配并放入向量。

一个

std:：vector

容器在销毁时不会自动删除插入的元素。将其设为

std:：vector

，其中x是一些合适的智能指针模板，如

auto\u ptr

如果您不想这样做，那么下一个最好的方法是将该向量包装到一个类中，该类的析构函数迭代该向量，并在每个指针上调用delete

即，这是内存泄漏：

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;
          }
         }

{
std:：vec；
向量推回（新整数[3]）；
//vec超出范围
}

---

当然，向量会自己清理！它会删除它的内部数组，等等。但是它不会对

newint[3]执行任何操作
我们分配和放入向量。V/GP在哪里告诉你内存丢失？你在泄露，因为你在使用<代码>新< /C> >和代码>删除< /C>。你不需要在C++中使用<代码>删除>代码>，只需要在非常具体的情况下使用<代码>新< /C> >，这不适用于你的例子。使用和使用标准容器。
TakeAwayBoard*b=新的TakeAwayBoard（…）
？您是否在某个地方释放
*b
，例如在
位置：：~Position（）
？我想我们需要更多的代码（以及准确/完整的valgrind错误报告）@avakar什么？如果你需要使用
new
，无论情况多么具体，你也需要使用
delete
。@MrLister:如果你使用
new
，那么必须使用
delete
，但这应该是某种资源管理对象，而不是你。当然，除非你喜欢调试内存泄漏Valgnand告诉你内存丢失了吗？因为你在使用<代码>新< /代码>和<代码>删除<代码>。你不需要在C++中使用<代码>删除>代码>，只需要在非常具体的环境下使用<代码>新的<代码>。这不适用于你的例子。AwayBoard*b=新的外卖板（…）

？你有空吗