为什么在重新分配其他向量时std :: vector迭代器无效？

Question

That's not the exact same copy of other questions on the topic. I've just stumbled into something really strange and can't get how this happened.

struct Edge{
    int vertex_a{ 0 };
    int vertex_b{ 0 };
};
typedef std::vector<Edge> EdgeList;

struct Vertex{
    std::vector<int> edge_indices;
};

typedef std::vector<Vertex> VertexList;

    void ContractEdge(int edge_index){
            static int iter = 0;
            ++iter;
            auto& edge = edge_list[edge_index];
            auto& vertex_a = vertex_list[edge.vertex_a - 1];
            auto& vertex_b = vertex_list[edge.vertex_b - 1];
            auto dead_vertex_index = edge.vertex_b;
            std::vector<int> self_edge_array;
            auto& indices = vertex_b.edge_indices;

            for (auto it = indices.begin(); it != indices.end();++it){
                auto current_index = *it;
                auto& edge_of_b = edge_list[current_index];
                if (edge_of_b.vertex_a == dead_vertex_index){
                    edge_of_b.vertex_a = edge.vertex_a;
                }
                if (edge_of_b.vertex_b == dead_vertex_index){
                    edge_of_b.vertex_b = edge.vertex_a;
                }
                if (edge_of_b.vertex_a == edge_of_b.vertex_b){
                    self_edge_array.push_back(current_index);
                }
                else{
//this is the line where reallocation happens
                    vertex_a.edge_indices.push_back(current_index);
                }
            }
            RemoveVertexFromGraph(dead_vertex_index);
            int d = 0;
            for (auto& x : edge_list){
                if ((x.vertex_a > vertex_list.size()) || (x.vertex_b > vertex_list.size()))
                    ++d;
            }
            if (d)
                ++d;

            std::sort(self_edge_array.rbegin(), self_edge_array.rend());
            for (auto self_edge : self_edge_array){
                RemoveEdgeFromGraph(self_edge);
            }
        }

In the middle of this function I'm iterating over indices vector of one vertex and occasionly push_back some values to the indices vector of other vertex.

While running this code , I've started to recieve error message "Vector iterator not icrementable". I've decided to debug closer and found that when I do certain amount of push_back s here vertex_a.edge_indices.push_back(current_index) , and both the size and the capacity of the vector is 19, the vector implementation calls _Reserve(1) method, which calls some reallocate method. And after that the indices vector gets reallocated automaticly with all pointers inside of it pointing to the other memory block. That's why the auto it iterator can not be nor compared not incremented, because it becomes invalid pointing to some wrong place.

Answer 1

Thanks for your comments. It turned out that at the moment that the problem happens I'm actually pushing_back against the same vector I'm iterating in. And of course this invalidates iterators. So the problem occured to be in a bad data organization and bad coding style. I'm looking at your comments now and I understand now that my code is pretty bad. Thanks for indicating that. I've also didnt put the whole code for review, because thought it would be enough but sure I could at least show that it is a class and it has some members. And reveal more structure. Again sorry for that. I think I'd probably need to come up with some other data structure, maybe not doing any dynamic reallocations until the inner algorithm is done. Also the 0 and 1 indexing is lame, I know that. I'm just doing a course task and the task is in txt file and has 1-based indexing.

And yes, d and iter were for breakpoints