C++ 在while循环内的变量中分配新内存

我有一个

Town

类，它表示图形中的节点，如下所示：

class Town
{
public:
    Town();
public:
    Town* _parent;

    int _name;
    int _row;
    int _column;
    State _state;

    vector<Town*> _neighbors;
};

然后我的AI类接收一个

Map

对象，并根据算法进行求解，现在我正在实现Astar

class AI
{
private:
    struct TownWithCost
    {
        Town town;
        double cost;
    };

    struct OrderByTotalCost
    {
        bool operator()(TownWithCost lfs, TownWithCost rhs)
        {
            return lfs.cost > rhs.cost;
        }
    };
public:
    AI(Map map);
private:
    bool AStar(Town* town);

    double GetTotalCost(Town town);

public:
    bool _success;
private:
    Map _map;
};

以下是我的Astar实现：

bool AI::AStar(Town* town)
{
    AI::OrderByTotalCost comparator;
    vector<TownWithCost> priorityQueue;

    TownWithCost currentTown = { *town, 0 };
    Town temp = currentTown.town;

    priorityQueue.push_back(currentTown);

    SetEnvironment(temp, State::visited);

    while (!priorityQueue.empty())
    {
        currentTown = priorityQueue.front();
        Town temp = currentTown.town;

        priorityQueue.erase(priorityQueue.begin());

        SetEnvironment(temp, State::visited);
        PrintEnvironment();

        if (temp._name == _map._exit->_name)
        {
            return true;
        }

        vector <Town*> neighbors = town->_neighbors;

        for each (Town* neighbor in neighbors)
        {
            Town tempNeighbor = *neighbor;

            if (tempNeighbor._state == State::town)
            {
                tempNeighbor._parent = &temp;
                TownWithCost neighborWithCost = { tempNeighbor, GetTotalCost(tempNeighbor) };

                priorityQueue.push_back(neighborWithCost);
            }
        }
        make_heap(priorityQueue.begin(), priorityQueue.end(), comparator);
    }
    return false;
}

bool AI:：AStar（镇*Town）
{
AI:：OrderByTotalCost比较器；
向量优先队列；
TownWithCost currentTown={*town，0}；
城镇温度=currentTown.Town；
优先队列。推回（当前城镇）；
SetEnvironment（温度、状态：：已访问）；
而（！priorityQueue.empty（））
{
currentTown=priorityQueue.front（）；
城镇温度=currentTown.Town；
擦除（priorityQueue.begin（））；
SetEnvironment（温度、状态：：已访问）；
打印环境（）；
如果（温度\名称==\映射\退出->\名称）
{
返回true；
}
矢量邻居=城镇->城市邻居；
每个（城镇*邻居中的邻居）
{
城镇临时邻居=*邻居；
如果（临时邻居州==州：：镇）
{
临时邻居。\u父项=&temp；
TownWithCost neighborWithCost={tempNeighbor，GetTotalCost（tempNeighbor）}；
优先队列。向后推_（邻里免费）；
}
}
生成堆（priorityQueue.begin（）、priorityQueue.end（）、比较器）；
}
返回false；
}

正如您可能注意到的，我还没有实现查看

优先队列

中是否已经有

城镇

，并比较成本以确定我想要保留哪一个，但我计划在解决当前问题后实现

我的问题是，我不希望在

priorityQueue

中有指针。我试图使临时变量，这将复制一个城市，它的成本从某个路径

假设我从镇上开始

9

9

有邻居

0

，

7

，

8

，

3

，具体来说，第一个循环中的

优先级队列

如下所示：

class Town
{
public:
    Town();
public:
    Town* _parent;

    int _name;
    int _row;
    int _column;
    State _state;

    vector<Town*> _neighbors;
};

然后我得到

3

作为我的当前城镇，我正在检查它的邻居

当我到达线路

Town temp=currentTown.Town时

第二次将

priorityQueue

中每个元素的父元素设置为

3

。现在我明白了为什么会发生这种情况，我不明白的是如何防止这种情况

我基本上需要的是

priorityQueue

以不同的父级和不同的成本存储相同的城镇（而不是相同的内存地址）（我已经用struct

TownWithCost

处理了单独的成本）。总之，每次都要复印

例如，我可以直接从

9

到

0

，总成本为81，但我也可以通过

3

（

9->3->0

）到

0

，总成本为50。我希望能够区分这两种

如何在我的

priorityQueue

中区分它们，如何避免重置父级，或者换句话说，如何在循环每次运行时将另一部分内存分配给

Town temp

，以便每次都有不同的temp

---

如果你有另一种方法（尽可能对新手友好），那就说吧。

你传递的是

Map

的值实例，这个类没有复制构造函数或赋值操作符。当这个类被浅层复制（alamemcpy）

vector

实例被销毁（多次）时会导致崩溃

---

尝试使用指针或引用。也会更快。

您还可以使用指向数组或城镇向量的索引向量。不需要指针。但就我个人而言，我更喜欢使用std:shared\u ptr

为什么要使用指针向量？为什么不只是一个对象向量？@caps你是指

优先队列

？因为我把它作为

TownWithCost

的向量，它使用

Town

和

int

。除非您谈论的是

Town*_parent

变量。我不知道还有什么别的方法可以把我从一个小镇带回到它来自的小镇，而不需要指针我这样做是因为每个向量元素都指向一个

\u map[][]

城镇元素。但别担心，这个向量根本没有被Astar使用，这就是为什么我再次问这个问题。我要问的具体问题是如何在while循环中的变量中分配新内存，或者如何实现astari的优先级队列如果你是说在Astar中通过指针执行所有操作，这是我做的第一件事，它抛出了错误

无效堆

，因为

GetTotalCost（）

改变了堆中每个元素的成本，这就是为什么我尝试复制所有我没有成功的东西。没问题。演出留到最后。但是你需要编写复制构造函数和赋值运算符。我想把

Town

存储在

TownWithCost

中，我每次都可以存储一个索引向量，这几乎就是每次的路径，但我想找到一种更优雅的方法来实现我的目标。但是如果我不能做到这一点，那么最后我可能会再次尝试向量方法。我也听到很多人在谈论<代码> STD::SyrdYPPTR < /Cord>。但是我个人没有经验，因为我是C++新手（一般是编程），这就是为什么我没有使用它。