stl-iterator bringt mich zum verzweifeln...

[flowerpower]

Holla Leute,
Ich haette folgende frage bezueglich eines STL-iterators. Der folgende code-ausschnitt wird vielleicht manche die stl kennen zum stutzen bringen, aber der code beruht auf ner library, die wiederum direkt auf der stl aufbaut.
Also die Iteratoren, die verwendet werden sind gleich zu setzen mit den aus der STL bekannten iteratoren und funzen auf gleiche Weise.

Nun zum code. Der code-ausschnitt behandelt Kanten von graphen. Der Iterator der hier verwendet wird wandert durch alle Kanten des graphen. an einer bestimmten stelle wird eine Kante mittels der methode "hide_edge" quasi geloescht, was dann aber wiederum den Iterator ungueltig macht.
Daher wird ein zweiter Iterator verwendet der, bevor die Kante geloescht wird, inkrementiert wird.

Das Problem ist das ich ne Endlosschleife bekomme. Es wird zwar durch alle Kanten durchgegangen aber es endet nicht.

Ich vermute, dass durch das "restore_edge" was ich mache, die Kante wieder sichtbar wird und in die liste der existierenden kanten wieder eingefuegt wird, sodass inkonsistenzen entstehen.

Sorry fuer den langen request (habe die leute von der library schon angemailt aber ist schon etwas laenger her und habe noch keine antwort), vielleicht habt ihr ne idee.

Hier der code-ausschnitt (ihr koennt ihn zwar nicht testen, wegen der lib-funktionen, aber vielleicht gibts ne idee):

int main(int argc, char *argv[])
{
  // graph erzeugen ...
  graph g; g.make_undirected();
  node n0 = g.new_node(); node n1 = g.new_node();
  node n2 = g.new_node(); node n3 = g.new_node();
  node n4 = g.new_node(); node n5 = g.new_node();
  node n6 = g.new_node();

  edge e0 = g.new_edge(n0, n2);
  edge e1 = g.new_edge(n0, n1);
  edge e2 = g.new_edge(n0, n3);
  edge e3 = g.new_edge(n1, n3);
  edge e4 = g.new_edge(n2, n3);
  edge e5 = g.new_edge(n3, n4);
  edge e6 = g.new_edge(n4, n5);
  edge e7 = g.new_edge(n5, n6);

  // iteratoren, die ueber alle kanten wandern und wie stl-iteratoren funzen ..
  graph::edge_iterator all_edges_begin = g.edges_begin();
  graph::edge_iterator all_edges_end   = g.edges_end();
  graph::edge_iterator tmp_edges_begin = g.edges_begin();
  while(all_edges_begin != all_edges_end)
  {
    // merke aktuellen iterator-pos ..
    tmp_edges_begin = all_edges_begin;

    // naechste position merken ...
    ++tmp_edges_begin;

    // hier wird das aktuelle element (eine kante) aus der liste aller gueltigen
    // kanten herausgenommen ...
    g.hide_edge(*all_edges_begin);

    // hier ist das vorher versteckte element wieder da ...
    g.restore_edge(*all_edges_begin);

    // die aktuelle position aktualisieren ...
    all_edges_begin = tmp_edges_begin;
  }

  return 0;
}

Der code-auschnitt den ich in nem manual fuer library gesehen als vorschlag sieht wie folgt aus:

graph::edge_iterator it = g.edges_begin();
  graph::edge_iterator end   = g.edges_end();
  graph::edge_iterator tmp;
  while(it!=end)
  {
     if(/* some condition on *it */)
     {
         tmp = it;
         ++tmp;
         g.hide_edge(*it);
         it = tmp;
     }
     else
     {
       ++it;
     }
  }

hier ist allerdings kein g.restore_edge gegeben und die if-abfrage in der schleife ist in meinem fall nicht noetig.

Vielen Dank fuer die Ideen und die Geduld beim lesen vorab.

Gruss

[Walli]

Versuch es mal so. Keine Garantie!

// ...
while(all_edges_begin != all_edges_end)
{
  g.hide_edge(*all_edges_begin);
  g.restore_edge(*all_edges_begin++);
}
// ...

[ Dieser Beitrag wurde am 14.06.2003 um 17:04 Uhr von MaSTaH editiert. ]