我正在为《尖峰时刻》（游戏）写一个A* 算法，以便学习基础知识。为此，我编写了一个名为Board的类，其示例也充当A* 搜索的“节点”。
为了让算法工作，我生成（generate_moves()）可能的移动作为新的Board，并将它们作为子节点添加到原始棋盘（std::priority_queue命名为children）。
出于某种原因，当我决定从std::priority_queue children容器中获取Board时，它指向父对象（Board* parent）的指针（在生成过程中分配）变成了指向它自己的指针。
1.缩写generate_moves()函数：

"for each possible move do"
...
Board newBoard = Board();
...
newBoard.parent = this; // I understand 'this' to always point towards the function caller.
children.push(newBoard); // Priority queue of the current board
...

下图显示了从root扩展单个节点后，在a_star()函数（以调用Board为root）中调试过程，同时抓取第一个'child'：before top()正如你所看到的，open优先级队列中的每个元素都有根父节点，它自己的父节点是'nullptr'（这是正确的，根节点没有父节点）。
custom score-comparing class Compare for the priority queues正如你所看到的，一切都已经一团糟了。从第一次比较开始，父节点的parent指针指向每个子节点，而不是nullptr。
after top() (Board currNode)在优先级队列退出top()之后，节点现在混乱了，有一个自引用的父节点。
after top() (priority_queue open)open优先级队列中的每个Board也是如此，它有一个自引用父级。
我一直在涉足这个问题很长一段时间了。任何帮助都将不胜感激。如果您需要任何额外的背景，请让我知道。
我试过了

• 用我自己的类型替换priority_queue，但我最终处理了“const”必需值的问题，为此我最终创建了基本相同的类。
• 给出父指针作为构造函数参数。什么都没改变。
• 我没有使用OPEN priority_queue的副本来进行一些需要弹出的比较（我不想对原始的进行这样的比较），而是尝试弹出原始的，然后将节点推回，因为“复制”位可能是问题所在。什么都没改变。
• 我将比较函数从比较参考值（Board&）改为比较正常值（Board），因为问题似乎发生在比较过程中。什么都没改变。

编辑：这是我尝试的一个“最小可重复的例子”。不确定是否一致，因为使用兰德（）来简化一些函数，但它展示了完全相同的问题：

#pragma once
#include <iostream>
#include <bitset>
#include <vector>
#include <queue>
#include <stdexcept>

using namespace std;

class SimplifiedBoard {
public:
    bitset<36> board;
    class Compare {
    public:
        bool operator() (SimplifiedBoard& a, SimplifiedBoard& b) {
            return (a.fscore < b.fscore);
        }
    };
    int fscore;
    priority_queue<SimplifiedBoard, vector<SimplifiedBoard>, Compare> children;
    SimplifiedBoard* parent;

    SimplifiedBoard() {
        fscore = 0;
        parent = nullptr;
    }

    // Move generator
    void generateMoves() {
        int arbitraryChildren = 5;
        for (int i = 0; i < arbitraryChildren; i++) {
            SimplifiedBoard newBoard = SimplifiedBoard();
            newBoard.fscore = (int)rand() / 100;
            // Assign parent to child
            newBoard.parent = this;
            // Add new child
            children.push(newBoard);
        }
    }

    // A*
    vector<SimplifiedBoard> aStar(SimplifiedBoard& start) {
        priority_queue<SimplifiedBoard, vector<SimplifiedBoard>, Compare> open = {};
        vector<SimplifiedBoard> closed = {};
        start.fscore = 0;
        start.parent = nullptr;
        open.push(start);

        // Loop
        while (!open.empty()) {
            // ***BUG HAPPENS here (2nd cycle, after root node has been expanded and closed)****
            SimplifiedBoard currNode = open.top(); open.pop();
            if (currNode.parent != nullptr &&
                currNode.parent->parent != nullptr &&
                currNode.parent == currNode.parent->parent) {
                cout << "Self-referential bug!" << endl;
            }
            // *** Here, in 2nd cycle, currNode.parent suddenly references a node which references itself ***
            
            // Child generation. f,g,h scores and 'parent' assigned inside function
            currNode.generateMoves();

            // For each child check OPEN/CLOSE and and see if I add to OPEN
            auto childrenCopy = currNode.children;
            for (int i = 0; i < (int)currNode.children.size(); i++) {
                bool isWorse = false;
                SimplifiedBoard currChildNode = childrenCopy.top(); childrenCopy.pop();

                // Victory?
                if (currChildNode.isVictory()) {
                    closed.push_back(currChildNode);
                    // Path reconstruction
                    vector<SimplifiedBoard> path = {};
                    SimplifiedBoard currPathNode = currChildNode;
                    // Ciclo child->parent
                    while (currPathNode.parent != nullptr) {
                        path.push_back(currPathNode);
                        currPathNode = *currPathNode.parent;
                    }
                    // Insert root
                    path.push_back(currPathNode);
                    // Return path
                    return path;
                }
                // OPEN
                auto openCopy = open;
                for (int j = 0; j < (int)open.size(); j++) {
                    SimplifiedBoard currOpenNode = openCopy.top(); openCopy.pop();
                    if (currChildNode.fscore <= currOpenNode.fscore) {
                        isWorse = true; break;
                    }
                }
                if (isWorse) { continue; }

                // CLOSED
                for (int j = 0; j < (int)closed.size(); j++) {
                    ;
                    if (currChildNode.fscore <= closed[j].fscore) {
                        isWorse = true; break;
                    }
                }
                if (isWorse) { continue; }

                //
                open.push(currChildNode);
            }
            // Close the node
            closed.push_back(currNode);
        }
        // return empty if can't find goal
        return vector<SimplifiedBoard>();
    }

    // Check victory
    bool isVictory() {
        if ((int)rand() % 50 == 5) { return true; }
        else { return false; }
    }
};

int main() {
    // Debug_example
    srand((int)time(NULL));
    SimplifiedBoard b = SimplifiedBoard();
    cout << "If it gets stuck the bug is happening:" << endl;
    vector<SimplifiedBoard> res = b.aStar(b);
    for (int i = 0; i < (int)res.size(); i++) {
        cout << res[i].fscore << endl;
    }
}