g ++ 최적화로 인해 프로그램을 실행할 수 없습니다.

D * -Lite를 기반으로 경로 계획 알고리즘을 구현했습니다. 최적화 (-O0)를 설정하지 않으면 프로그램이 정상적으로 실행될 수 있습니다. 하지만 최적화 수준 (-O1 / 2 / 3)을 켜면 프로그램을 종료 할 수 없습니다. 에서 Visual Studio를 모두 디버그 모드와 릴리즈 모드는 일반적으로 실행할 수 있습니다. 위의 경우 코드는 동일합니다 . 문제를 찾는 방법을 모르겠습니다. 누구든지 도와 줄 수 있습니까?

class DstarLite {
public:
  DstarLite() = delete;
  DstarLite(GridStatus* a, GridStatus* b, FILE* fp)
      : k_m_(0), start_(a), last_(start_), goal_(b), open_close_(fp) {}
  void calculateKey(GridStatus* s);
  void updateVertex(GridStatus* u);
  void initialize();
  void computeShortestPath();
  void rePlanning(vector<pair<GridStatus*, int>>& node_change);
  GridStatus* getStart();
  void setStart(GridStatus* val);
  GridStatus* getGoal();

private:
  Fib frontier_;  
  double k_m_;
  unordered_map<GridStatus*, handle_t>
      heap_map_;  
  GridStatus* start_;
  GridStatus* last_;  
  GridStatus* goal_;
  FILE* open_close_;
};

void DstarLite::calculateKey(GridStatus* s) {
  s->f = min(s->g, s->rhs) + heuristic(start_, s) + k_m_;
  s->k2 = min(s->g, s->rhs);
}

void DstarLite::initialize() {
  fprintf(open_close_, "%d %d\n", start_->x, start_->y);
  fprintf(open_close_, "%d %d\n", goal_->x, goal_->y);
  goal_->rhs = 0;
  calculateKey(goal_);
  handle_t hand = frontier_.push(goal_);
  heap_map_[goal_] = hand;
}

void DstarLite::updateVertex(GridStatus* u) {
  bool heap_in = heap_map_.find(u) != heap_map_.end();
  if (u->g != u->rhs && heap_in) {
    calculateKey(u);
    frontier_.update(heap_map_[u]);
  } else if (u->g != u->rhs && !heap_in) {
    calculateKey(u);
    handle_t hand = frontier_.push(u);
    heap_map_[u] = hand;
  } else if (u->g == u->rhs && heap_in) {
    calculateKey(u);
    frontier_.erase(heap_map_[u]);
    heap_map_.erase(u);
  }
}

void DstarLite::computeShortestPath() {
  int count = 0;
  while (smaller(frontier_.top(), start_) || !myEqual(start_->rhs, start_->g)) {
    count++;
    auto u = frontier_.top();
    pair<double, double> k_old = {u->f, u->k2};
    pair<double, double> k_new;
    k_new.first = min(u->g, u->rhs) + heuristic(start_, u) + k_m_;
    k_new.second = min(u->g, u->rhs);
    if (k_old < k_new) {
      calculateKey(u);
      frontier_.update(heap_map_[u]);
    } else if (myGreater(u->g, u->rhs)) {
      u->g = u->rhs;
      frontier_.pop();
      heap_map_.erase(u);
      for (auto s : neighbors(u)) {
        if (s->rhs > u->g + cost(u, s)) {
          s->next = u;
          s->rhs = u->g + cost(u, s);
          updateVertex(s);
        }
      }
    } else {
      double g_old = u->g;
      u->g = kDoubleInfinity;
      auto neighbor = neighbors(u);
      neighbor.push_back(u);
      for (auto s : neighbor) {
        if (myEqual(s->rhs, cost(s, u) + g_old)) {
          if (!equal(s, goal_)) {
            double pp_s = kDoubleInfinity;
            for (auto succ : neighbors(s)) {
              double dis = succ->g + cost(succ, s);
              if (dis < pp_s) {
                pp_s = dis;
                s->next = succ;
              }
            }
            s->rhs = pp_s;
          }
        }
        updateVertex(s);
      }
    }
  }
  cout << "Dstar visited nodes : " << count << endl;
}

void DstarLite::rePlanning(vector<pair<GridStatus*, int>>& node_change) {
  k_m_ += heuristic(last_, start_);
  last_ = start_;

  for (auto change : node_change) {
    GridStatus* u = change.first;
    int old_threat = u->threat;
    int new_threat = change.second;

    double c_old;
    double c_new;


    u->threat = new_threat;
    u->rhs += (new_threat - old_threat) * threat_factor;
    updateVertex(u);

    
    for (auto v : neighbors(u)) {
      u->threat = old_threat;
      c_old = cost(v, u);
      u->threat = new_threat;
      c_new = cost(v, u);
      if (c_old > c_new) {
        
        if (v != goal_) {
          if (v->rhs > u->g + c_new) {
            v->next = u;
            v->rhs = u->g + c_new;
          }
        }
      } else if (myEqual(v->rhs, c_old + u->g)) {
        if (v != goal_) {
          double pp_s = kDoubleInfinity;
          for (auto pre : neighbors(v)) {
            double dis = pre->g + cost(pre, v);
            if (dis < pp_s) {
              pp_s = dis;
              v->next = pre;
            }
          }
          v->rhs = pp_s;
        }
      }
      updateVertex(v);
    }
  }
}

GridStatus* DstarLite::getStart() { return start_; }

void DstarLite::setStart(GridStatus* val) { start_ = val; }

GridStatus* DstarLite::getGoal() { return goal_; }

  DstarLite dstar(start, goal, open_close);
  dstar.initialize();
  dstar.computeShortestPath();

죄송합니다. 코드에서 문제를 찾기가 어려우므로 코드는 이전에 표시되지 않았습니다. 이제 질문을 다시 편집했지만 코드가 많이 있으며 주요 호출 부분은 computeShortest () 입니다.