2016-07-26 10 views
0

Stellen Sie sich eine Eisenbahnlinie vor. Wir haben einige Stationen und einige Abschnitte, wo der Zug mit reduzierter Geschwindigkeit (Reduspeeds) fährt. Diese Abschnitte können Stationen enthalten. Ich muss die Abschnitte in Teile teilen, die keine Stationen enthalten.Soll ich list :: iterator aktualisieren, wenn die Liste Speicher neu zuordnet?

Zum Beispiel: Von der 1500. m bis zur 3500. m der Linie kann der Zug mit nur 40 km/h fahren. Ich habe zwei Stationen auf 2000 m und 3000 m. In diesem Fall muss ich 3 Abschnitte haben: 1500m - 2000m, 2000m - 3000m und 3000m - 3500m.

Also meine ursprünglichen reduspeed Abschnitte in eine std :: list, und meine while (for()) Doppelschleife geht durch und findet heraus, ob es innere Stationen hat. Hat man:

  1. die Funktion in zwei Teile spaltet (temp_speed_section_1 und 2)
  2. Einsätze diese Teile vor dem eigentlichen reduspeed_section in der Liste
  3. die ursprüngliche reduspeed_section 2 bewegt den Iterator
  4. löscht Positionen zurück (was das in temp_speed_section_1 gespeicherte Objekt sein sollte)
  5. setzt die Suche mit dem neu eingefügten reduspeed_section fort (weil der ursprüngliche Abschnitt mehr Stationen enthalten kann)

Mein Code:

namespace split 
{ 
/** \brief Finds reduspeed sections (left) with inner station(s) and splits them into equivalent reduspeed sections without inner stations 
* 
* \param const &reduspeeds_left the origial vector of reduspeeds 
* \param const &stations   the stations of the line 
* \return &split_reduspeeds  the list to hold the new split and unchanged reduspeed sections 
* 
*/ 

    bool FindOverhangingReduspeedSectionsLeft(std::vector <speed_section> const &reduspeeds_left, std::vector <station> const &stations, 
               std::list <speed_section> &split_reduspeeds) 
    { 
     std::copy(reduspeeds_left.begin(), reduspeeds_left.end(), std::back_inserter(split_reduspeeds)); 
     std::list<speed_section>::iterator iter_list_reduspeeds = split_reduspeeds.begin(); 
     int items_stations = stations.size(); 
     speed_section temp_speed_section_1; 
     speed_section temp_speed_section_2; 

     while(iter_list_reduspeeds != split_reduspeeds.end()) 
     { 
label_1: 
      for (int j=0; j<items_stations; j++) 
      { 

       if (iter_list_reduspeeds->its_start < stations[j].its_left_station && stations[j].its_left_station < iter_list_reduspeeds->its_end) 
       { 
        temp_speed_section_1.its_start = iter_list_reduspeeds->its_start; 
        temp_speed_section_1.its_end = stations[j].its_left_station; 
        temp_speed_section_1.its_speed = iter_list_reduspeeds->its_speed; 

        temp_speed_section_2.its_start = stations[j].its_left_station; 
        temp_speed_section_2.its_end = iter_list_reduspeeds->its_end; 
        temp_speed_section_2.its_speed = iter_list_reduspeeds->its_speed; 

        split_reduspeeds.insert(iter_list_reduspeeds, temp_speed_section_1); 
        split_reduspeeds.insert(iter_list_reduspeeds, temp_speed_section_2); 

        split_reduspeeds.erase(iter_list_reduspeeds); 
        /// In order to avoid the need for sorted "stations" vector/list, iterator goes to the first part of the actual reduspeed 
        --iter_list_reduspeeds; 
        --iter_list_reduspeeds; 

        goto label_1; 
       } 
      } 

      ++iter_list_reduspeeds; 
     } 
     return 0; 
    } 

So ist die Funktion mit einer Station ein resduspeed Abschnitt findet, sie in zwei Teile teilt, so dass sie in die Liste einfügt, löscht das Original und repositioniert den Iterator. An dieser Stelle zeigt der Iterator auf ein speed_section-Objekt (korrekt), aber die Elementvariablen dieses Objekts haben einige zufällige Werte. Die while-Schleife stürzt beim nächsten Mal ab, wenn sie versucht, ein neues Objekt in die Liste einzufügen.

Ich versuchte, aber faild, um herauszufinden, was das Problem ist. Ist es möglich, dass, wenn ich die neuen Werte in die Liste einfüge, der Speicher neu zugewiesen wird, aber der Iterator sich selbst nicht "auffrischen" kann, oder so ähnlich?

+0

ersetzen auch 'if' mit' while' und entfernen 'goto'. – LogicStuff

+0

Es ist nicht die Liste Fehler; Speicher wird nicht neu zugewiesen (Vektor _zuweisen Speicher neu zuweisen). _Sie_ löschen ein Element und dies macht diesen spezifischen Iterator ungültig. – MSalters

Antwort

0

std::list::erase entkräftet den angegebenen Iterator, müssen Sie iter_list_reduspeeds im Ergebnis speichern:

iter_list_reduspeeds = split_reduspeeds.erase(iter_list_reduspeeds); 
std::advance(iter_list_reduspeeds, -2);