C++ 存储std:：deque的迭代器

我试图将deque的迭代器存储在一个向量中，并希望在向量中保留它们，即使我已经从deque中删除或插入了一些元素。这可能吗

我有以下代码：

typedef struct {

int id;
int seedId;
double similarity;

} NODE_SEED_SIM;

typedef std::deque<NODE_SEED_SIM> NodesQueue;
typedef std::deque<NODE_SEED_SIM>::iterator ITRTR;
typedef std::vector<const ITRTR> PointerVec;  

void growSegments (CSG_PointCloud *pResult, IntMatrix *WdIndices, NodesQueue *NodesList, IntMatrix *Segments) {

    ITRTR nodeslistStart = (*NodesList).begin();
    int pointCount = (*WdIndices).size();
    int nodeslistSize = (*NodesList).size();

    IntVector book(pointCount);
    PointerVec pointerList (pointCount); // Vector of ITRTRs

    for (int i = 0; i < nodeslistSize; i++) {

         book [ (*NodesList)[i].id ] = 1;
         pointerList [ (*NodesList)[i].id ] = nodeslistStart + i; // REF: 2

    }

    while (nodeslistSize > 0) {

    int i = 0;
    int returnCode = 0;
    int nodeId = (*NodesList)[i].id;
    int seedId = (*NodesList)[i].seedId;
    int n_nbrOfNode = (*WdIndices)[ nodeId ].size();

    (*Segments)[ seedId ].push_back ( nodeId );
    (*NodesList).erase ( (*NodesList).begin() ); // REF: 3; This erase DOES NOT mess the pointerList
    nodeslistSize --;

    Point node;
    /*
               GET ATTRIBUTES OF NODE
            */

    for (int j = 0; j < n_nbrOfNode; j++) {

        int nborId = (*WdIndices)[nodeId][j];

        if (nborId == seedId)
            continue;

        Point neighbor;
        /*
                        GET ATTRIBUTES OF NEIGHBOUR
                    */

        double node_nbor_sim = computeSimilarity (neighbor, node);

        if (book[nborId] == 1) {

            ITRTR curr_node = pointerList[nborId]; // REF: 1

            if ( curr_node -> similarity < node_nbor_sim) {

                curr_node -> similarity = node_nbor_sim;
                NODE_SEED_SIM temp = *curr_node;
                (*NodesList).erase (curr_node); // REF: 4; This erase completely messes up the pointerList
                returnCode = insertSortNodesList (&temp, NodesList, -1);


            }

        }

    }

}

}

typedef结构{
int-id；
int-seedId；
双重相似性；
}节点\种子\ SIM；
typedef std:：deque NodesQueue；
typedef std:：deque:：迭代器ITRTR；
typedef std:：vector PointerVec；
无效增长段（CSG_PointCloud*pResult、IntMatrix*WDIndex、NodesQueue*NodesList、IntMatrix*段）{
ITRTR nodeslistStart=（*NodesList.begin（）；
int pointCount=（*wdindex）.size（）；
int nodeslistSize=（*NodesList）.size（）；
矢量书（点计数）；
PointerVec pointerList（pointCount）；//ITRTRs的向量
对于（int i=0；i0）{
int i=0；
int returnCode=0；
int nodeId=（*NodesList）[i].id；
int seedId=（*NodesList）[i].seedId；
int n_nbrOfNode=（*wdindex）[nodeId].size（）；
（*段）[seedId]。向后推（nodeId）；
（*NodesList.erase（（*NodesList.begin（））；//REF:3；此擦除不会弄乱指针列表
节点列表大小--；
点节点；
/*
获取节点的属性
*/
对于（int j=0；j相似性<节点或sim）{
当前节点->相似性=节点或sim；
节点\种子\模拟温度=*当前\节点；
（*NodesList）.erase（curr_node）；//REF:4；此擦除操作会完全弄乱指针列表
returnCode=insertSortNodesList（&temp，NodesList，-1）；
}
}
}
}
}

NodeList中的节点在其内部保留一个全局ID。然而，它们存储在节点列表中，不是根据这个全局ID，而是按照它们的“相似性”降序排列。因此，稍后，当我想从NodesList中获取与全局ID（代码中的nborID）[REF:1]相对应的节点时，我通过“pointerList”进行操作，我以前在这里存储了deque的迭代器，但根据节点的全局ID[REF:2]。我的指针列表在第一个擦除命令[REF:3]后保持为真，但在下一个擦除命令[REF:4]中会出错

这里怎么了？ 谢谢

我试图将deque的迭代器存储在一个向量中，并希望在向量中保留它们，即使我已经从deque中删除或插入了一些元素。这可能吗

正如上面所说的

很抱歉，我将此作为图像发布在这里，但格式太繁琐，无法在标记中复制

所以简单的回答是：不恐怕您无法安全地存储指向存储在

std:：deque

中的某些元素的迭代器，而迭代器在其他地方发生了更改

其他一些相关问答：

---

如果要创建

迭代器的
向量
，则需要执行以下操作：

#include<iostream>
#include <deque>
#include <vector>
using namespace std;
int main()
{
    deque<int> dq { 1, 2, 3, 4, 5, 6, 7, 8 };
    deque<int>::iterator it;

    vector<deque<int>::iterator> vit;
    for (it = dq.begin(); it != dq.end(); it++)
    {
        vit.push_back(it);
        cout << *it;
    }

    //note that `it` is a pointer so if you modify the `block` it points in your deque then the value will change.
    //If you delete it then you will have a segmenant fault.
    //--- Don't Do: while (!dq.empty()) { dq.pop_back(); } ---//

    for (size_t i = 0; i < vit.size(); i++)
    {
        cout << *vit[i];
    }

    system("pause");
    return 0;
}

#包括
#包括
#包括
使用名称空间std；
int main（）
{
deque dq{1,2,3,4,5,6,7,8}；
迭代器；
载体vit；
for（it=dq.begin（）；it！=dq.end（）；it++）
{
vit.向后推（it）；
法院：（你能推荐任何其他适合我用途的容器吗？@Avishedutta我说不出，如果它真的适用于你的用例，但可能是一个适合做这项工作的容器。”…在它被更改/删除后，你可能想…“请问通知机制是什么？这取决于你想做什么以及你想如何做执行此操作。例如，您可能希望重写pop_back（）函数以通知您，然后调用常用的pop_back（）函数