Die Funktion mit der ich ein Problem habe soll jede Route aus der Datenbank durchgehen und in einen Vektor jede vorhandene Stadt genau einmal schreiben. Leider kommt es beim ausführen der Funktion zu Problemen. Teste ich sie mit der kompletten Datenbank (ca.15 Datensätze) stürzt das Programm ohne Fehlermeldung beim ausführen der Funktion ab. Mit 2-3 Testdatensätzen lief die Funktion durch, hat allerdings Städte doppelt in den Vektor geschrieben. Ich dachte ja erst, dass vielleicht die Variable "vorhanden" in der Schleife verschattet wird, das scheint aber doch nich der Fall zu sein... Ich hoffe hier kann mir jemand helfen weil ich mich schon seit mehreren Stunden mit dem Problem rumschlage und keine Lösung finde...

Hier ist der Code:

Route ist ein Feld mit den Bestandteilen: Ort1, Ort2 (beides String), Entfernung, Geschwindigkeit (beides Float)
Routen ist ein Vektor aus Route

//Erzeugt für jede Stadt in der Datenbank einen Knoten
std::vector<std::string> erstelle_knoten(const Routen &allerouten) {
    Route r;
    std::vector<std::string> knoten_namen; //Hier wird jeder Stadtnamen genau einmal als Knoten angelegt
    for(unsigned int i=0; i<allerouten.size(); i++){ //Die Schleife wird für jede vorhandene Route einmal durchlaufen
      bool vorhanden=0; //Route schon vorhanden wird (wieder) auf "nein" gesetzt
      for (unsigned int j=0; j-1<knoten_namen.size(); j++){ //Schleife wird für jeden vorhandenen Knoten genau einmal durchlaufen
          if(allerouten[i].ort1() == knoten_namen[j]) vorhanden=1; //Wenn zu einer Stadt schon ein Knoten existiert wird vorhanden auf "ja" gesetzt
      }
      if (vorhanden == 0) knoten_namen.push_back(allerouten[i].ort1()); //Wenn noch kein Knoten zur Stadt existiert wird einer erstellt

    }
    //Das Gleiche nochmal für den 2. Ort ("Zielort") in jeder Route da er ja nicht automatisch auch als 1. Ort vorhanden sein muss
    for(unsigned int i=0; i<allerouten.size(); i++){
      bool vorhanden=0;
      for (unsigned int j=0; j<knoten_namen.size(); j++){
          if(allerouten[i].ort2() == knoten_namen[j]) vorhanden=1;
      }
      if (vorhanden == 0) knoten_namen.push_back(allerouten[i].ort2());
    }
    return knoten_namen;
}

für sowas:

bool vorhanden = false;
for(int i = 0; i < v.size(); i++)
{
  if(v[i] == "zusuchendes")
    vorhanden = true;
}

// machst du besser das:
bool vorhanden = (std::find(v.begin(), v.end(), "zusuchendes") != v.end());

Dann räumst erstmal auf und dann findet sich der fehler sicherlich

const Routen routensuche(const std::string &startort, const std::string &zielort, const std::string &suchtyp, const Routen &allerouten)
{
    Routen gefundeneRouten;
    std::vector<std::string> knoten_namen = erstelle_knoten(allerouten);
    adjacency_map_t adjacency_map = erstelle_karte(knoten_namen, suchtyp, allerouten); //Erstellt eine Verbindungsnetzkarte

    std::map<vertex_t, weight_t> min_distance;
    std::map<vertex_t, vertex_t> previous;
    //Startknotennummer suchen
    unsigned int startknoten=0;
    while (knoten_namen[startknoten] != startort and startknoten < knoten_namen.size()) startknoten++;
    DijkstraComputePaths(startknoten, adjacency_map, min_distance, previous); //Algorithmus der die kürzesten Routen zu allen möglichen Zielpunkten sucht und speichert

    //Zielknotennummer suchen
    unsigned int zielknoten=0;
      while(knoten_namen[zielknoten] != zielort and zielknoten < knoten_namen.size()) zielknoten++;

    //Gesamtroute in route r schreiben
    if(suchtyp == "entfernung") {Route r(startort,zielort,min_distance[zielknoten],0); //für kürzeste Distanz
                                 gefundeneRouten.push_back(r);}
    else {Route r(startort,zielort,0,min_distance[zielknoten]); //für kürzeste Durchschnittsgeschwindigkeit
          gefundeneRouten.push_back(r);} //Schreibt die gesamtroute in gefundeneRouten

//Hier tritt wahrscheinlich der Fehler auf...
    //Die Teilrouten in gefundeneRouten schreiben
    Routen teilrouten; //uebernimmt die gefundene Route als Routen
    Route teilroute; //gefundene Route wird hier gespeichert und spaeter in routen geschrieben
    //Teilknoten finden
    unsigned int anzahlTeilstuecke = 0;
    //Die folgende Funktion soll die Teilabschnitte finden und speichern
    std::list<vertex_t> path = DijkstraGetShortestPathTo(zielknoten, previous);
    std::list<vertex_t>::iterator path_iter = path.begin();
        for( ; path_iter != path.end(); path_iter++)
        {
            anzahlTeilstuecke += 1; //Zaehlt die Teilstuecke der Strecke
            std::string knoten_vorher; //wird benoetigt um die Route zum Teilstueck aus der Datenbank zu suchen
            if(anzahlTeilstuecke == 1) knoten_vorher = startort; //Wenn erste Teilroute beginne mit Startort
            else knoten_vorher = knoten_namen[(*path_iter - 1)]; //Wenn nicht dann Stadtname der letzten Teilroute
            teilrouten = rt2->suchen(knoten_namen[*path_iter], knoten_vorher); //sucht die Route zu den beiden Orten aus der Datenbank
            teilroute = teilrouten[0];
            gefundeneRouten.push_back(teilroute);
        }
    return gefundeneRouten;
}

Der Suchalgorithmus und seine Funktionen sind von http://en.literateprograms.org/Dijkstra's_algorithm_(C_Plus_Plus) und wurden im Prinziep nicht verändert. Das Problem ist eben die Anpassung an die Schnittstellen und das automatische Erstellen der Knoten und Adjastanz Karte.