std::out_of_range 在字符串向量中搜索匹配项时出现异常

Question

在我的 C++ 程序中，我有一个文本文件，我逐行读入一个名为 flights 的 vector，然后我在这个字符串向量中搜索一些字符串，但不幸的是，如果我找不到任何匹配项我收到以下错误

航班矢量具有以下格式：

EMA CDG BritishAirways 120 100
CDG VIE AirFrance 120 100
EMA VIE BritishAirways 150 300
EMA CDG AirFance 130 80
GRO FFF Rayanair 130 80
FFF HHH AirItalia 100 50

Unhandled exception at at 0x769E4598 in OOP project.exe: Microsoft C++ exception: std::out_of_range at memory location 0x0052F0F0.

我想我发现错误一定出在我的 connectedJourney 函数中：

/*  The following code searches for journeys that have a connection. so the use 2 different flights
First of all looks for flights that are leaving from the same airport that the user indicated and stores the flight details in "deptMatches". 
Secondly it will look for flights that have the destination that the user indicated and stores it in "destMatches". 
Thirdly it will check if the destination code of any of the deptMatches matches the departure code of any of the destMatches.*/
vector < vector < string >> connectedJourney(string airpCode1, string airpCode2, vector < string > flights) {
  vector < vector < string >> rawMatches;
  vector < string > deptMatches;
  for (unsigned int f1 = 0; f1 < flights.size(); f1++) {
    //store all the fligths that match the departure airport into deptMatches

    if (airpCode1 == flights[f1].substr(0, 3)) {

      deptMatches.push_back(flights[f1]);
    }
  }

  vector < string > destMatches;

  for (unsigned int f2 = 0; f2 < flights.size(); f2++) {
    //store all the fligths that match the departure airport into deptMatches

    if (airpCode2 == flights[f2].substr(4, 3)) { //the call stack says the error is at this line 

      destMatches.push_back(flights[f2]);
    }
  }

  if (deptMatches.size() == 0 || destMatches.size() == 0) {
    // check if there won't be any matches

    throw noEntryFound();

  } else {
    vector < string > cj_Matches; //connected journey matches
    for (unsigned int g1 = 0; g1 < deptMatches.size(); g1++) {

      for (unsigned int g2 = 0; g2 < destMatches.size(); g2++) {

        if (deptMatches[g1].substr(4, 3) == destMatches[g2].substr(0, 3)) {
          //if the arrival place of the first flight matches the departure place of the first flight then the details of both flights are saved into a vector within another
          rawMatches[0].push_back(deptMatches[g1]);
          rawMatches[1].push_back(deptMatches[g2]);
        }
      }
    }
    return rawMatches;
  }

}

如果有用，我也把我的整个项目上传到这里： https://drive.google.com/folderview?id=0B-VbnRtajCWIfmFxMk5UUncwSkNzNm8tT2xrU0hDM29kbzg4TUFKODJSUExMTV9oVDFncjA&usp=sharing

Answer 1

试试这个：

  for (unsigned int f2 = 0; f2 < flights.size(); f2++) {
     //store all the fligths that match the departure airport into deptMatches
     string code = flights[f2];
     if (code.length() > 7 && airpCode2 == flights[f2].substr(4, 3)) { //the call stack says the error is at this line 

    destMatches.push_back(flights[f2]);
     }
  }

这就是我会做的：

   vector<string>::iterator iter = flights.begin(); 
   for (; iter!=flights.end(); ++iter) {
      istringstream is(*iter);
      string tokens[5];
      for (unsigned int i=0; i<5; ++i) {
     is >> tokens[i];
      }
      if (tokens[0] == airpCode1) {
     deptMatches.push_back(*iter);
      }
      if (tokens[1] == airpCode2) {
     destMatches.push_back(*iter);
      }
   }

Answer 2

你应该查阅 "transitive closure" 和 Warshall 的算法。我认为我下面的代码可以满足您的要求。

#include <string>
#include <iostream>
#include <set>
#include <vector>
#include <sstream>
#include <stdexcept>

// if you prefer to 'weight' your search on time
// uncomment time and comment price
#define PRICE
//#define TIME

using namespace std;

static const size_t NUMFLIGHTS=6;

static const char* data[] {
   "EMA CDG BritishAirways 120 100",
      "CDG VIE AirFrance 120 100",
      "EMA VIE BritishAirways 150 300",
      "EMA CDG AirFance 130 80",
      "GRO FFF Rayanair 130 80",
      "FFF HHH AirItalia 100 50"};

struct flight {
   void set(const string& input) {
      istringstream is(input);
      is >> dept >> dest >> airways >> time >> price;
   }
   string dept;
   string dest;
   string airways;
   unsigned int time;
   unsigned int price;
};

struct travelData {
   travelData() : weight(0), infinity(true) {}
   vector<flight> flights;
   unsigned int weight;
   bool infinity;
   void print() {
      auto i=flights.begin();
      for (;i!=flights.end(); ++i) {
     cout << i->dept << " " << i->dest << endl;
      }
      cout << weight << endl;
   }
};

struct database {
   vector< vector<travelData> > allflights;
   flight flights[NUMFLIGHTS];
   vector<string> locations;
};


travelData FlightExists(const flight* flights, const string& dept, const string& dest) {
   travelData ret;
   for (size_t i=0; i<NUMFLIGHTS; ++i) {
      if (flights[i].dest == dest && flights[i].dept == dept) {
     ret.flights.push_back(flights[i]);
#ifdef PRICE
     ret.weight = flights[i].price;
#elif LENGTH
     ret.weight = flights[i].time;
#else
     ret.weight = 1;
#endif
     ret.infinity= false;
     return ret;
      }
   }
   return ret;
}



database setup()
{
   database ret;
   set<string> locationsSet;
   for (size_t i=0; i<NUMFLIGHTS; ++i) {
      ret.flights[i].set(data[i]);
      locationsSet.insert(ret.flights[i].dept);
      locationsSet.insert(ret.flights[i].dest);
   }
   copy(locationsSet.begin(), locationsSet.end(), back_inserter(ret.locations));

   size_t len = ret.locations.size();
   for (size_t i=0; i<len; ++i) {
      string searchDept = ret.locations[i];
      vector<travelData> row;
      for (size_t j=0; j<len; ++j) {
     string searchDest = ret.locations[j];
     if (i == j) {
        travelData blank;
        blank.infinity = false;
        row.push_back(blank);
     } else {
        row.push_back(FlightExists(ret.flights, searchDept, searchDest));
     }
      }
      ret.allflights.push_back(row);
   }

   // Warshalls algorithn
   for (size_t k=0; k<len; ++k) {
      for (size_t i=0; i<len; ++i) {
     for (size_t j=0; j<len; ++j) {
        travelData& d = ret.allflights[i][j];
        travelData& s1 = ret.allflights[i][k];
        travelData& s2 = ret.allflights[k][j];

        if (!s1.infinity && !s2.infinity) {
           int sum = s1.weight + s2.weight;
           if (d.infinity) {
          d.infinity = false;
          d.flights.insert(d.flights.begin(), 
                   s1.flights.begin(), 
                   s1.flights.end());
          d.flights.insert(d.flights.begin(), 
                   s2.flights.begin(), 
                   s2.flights.end());

          d.weight = sum;
           } else if (d.weight > sum) {
          d.flights.clear();
          d.flights.insert(d.flights.begin(), 
                   s1.flights.begin(), 
                   s1.flights.end());
          d.flights.insert(d.flights.begin(), 
                   s2.flights.begin(), 
                   s2.flights.end());
          d.weight = sum;
           }
        }
     }
      }
   }


   return ret;


}

size_t GetIndex(const database& db, const string search) {
   size_t len = db.locations.size();
   for (size_t i=0; i<len; ++i) {
      if (db.locations[i] == search) {
     return i;
      }
   }

   throw runtime_error("bogus search");
}

travelData GetResults(const database& db, const string& dept, const string& dest) {
   travelData ret;
   size_t i_index = GetIndex(db, dept);
   size_t j_index = GetIndex(db, dest);
   return db.allflights[i_index][j_index];
}

int main() {
   database db = setup();

   travelData result = GetResults(db, "GRO", "HHH");
   result.print();

   return 0;
}