Segmentierungsfehler beim Dereferenzieren von Vektor von Iteratoren

Question

Ich möchte einen Vektor von Iteratoren verwenden, um mit dem Inhalt eines Vektors < int> zu verknüpfen.
Wenn ich versuche, diesen Vektor von Iteratoren über einen einzigen Iterator "it" zu füllen, erhalte ich einen Segmentierungsfehler, wenn ich versuche, ihn zu dereferenzieren.

vector <int> vec; 
vector <int>::iterator it = vec.begin(); 
vector<vector <int>::iterator> vecIt(3); 
vec.push_back(1);  
vec.push_back(2); 
vec.push_back(3); 
vecIt[0] = it; 

cout << *vecIt[0] << endl; //this line causes seg. fault 

Allerdings, wenn ich meinen „es“ nicht Iterator verwenden, funktioniert es ganz gut:

vector <int> vec; 
vector<vector <int>::iterator> vecIt(3); 
vec.push_back(1); 
vec.push_back(2); 
vec.push_back(3); 
vecIt[0] = vec.begin(); 

cout << *vecIt[0] << endl; 

Könnte jemand dieses Verhalten mir das erklären? Was verursacht das seg. Fehler bei Verwendung eines zusätzlichen Iterators?
Gibt es auch eine bessere Möglichkeit, durch meinen Vektor < int> zu gehen und Iteratoren (oder Zeiger, wenn das ratsam ist) für den Vektor von Iteratoren zu speichern?

Answer 1

Von: http://en.cppreference.com/w/cpp/container/vector/push_back

Wenn die neue Größe() größer ist als Kapazität() dann alle Iteratoren und Verweise (einschließlich der past-the-End-Iterator) für ungültig erklärt werden. Sonst wird nur der Iterator über die Vergangenheit ungültig gemacht.

Somit wird durch den Iterator nehmen (es ist ein leerer Vektor, auch) und nehmen dann die Größe des Vektors übersteigen seine Kapazität push_back() durch den Aufruf, sind Sie, dass Iterator ungültig zu machen. Wenn Sie jedoch push_back() und dann den Iterator nehmen, keine Invalidierung auftritt, da die Größe des Vektors seine Kapazität nicht überschreitet.

Answer 2

Wenn Sie ein neues Element über

vec.push_back(1); 

schieben Die Iteratoren bekommen für ungültig erklärt. Siehe z.B. um cplusplus:

Wenn eine Neuzuweisung auftritt, werden alle Iteratoren, Zeiger und Verweise, die sich auf den Container beziehen, ungültig gemacht. Andernfalls wird nur der End-Iterator ungültig gemacht, und alle Iteratoren, Zeiger und Verweise auf Elemente verweisen garantiert immer auf dieselben Elemente, auf die sie sich vor dem Aufruf bezogen haben.