我自己的模板類中的向量std :: out_of_range（指向列表節點的指針的向量），但是我看不到為什么

Question

我正在為帶有鏈接列表的模板類和指向鏈接列表中某些節點的指針向量編寫代碼。 該代碼很丑陋，因為我只是寫了我認為可能有用的代碼，並針對錯誤消息進行了更正。

列表（根據向量也是如此）將保持排序，因為每次插入項目時，它都會使用position方法找到正確的位置。

最初，我有很多錯誤，經過大量嘗試，我能夠修復它們。 現在可以編譯了，但是如果此模板類可以正常工作，那么當我使用main方法對其進行測試時，它將引發錯誤消息：

拋出'std :: out_of_range'實例后調用終止

what（）：向量:: _ M_range_check

中止（核心已棄用）

我知道什么是std :: out_of_range，但是我真的不明白為什么會發生此錯誤。 我的代碼中甚至沒有很多部分可以訪問向量的元素。

以下是測試main方法的代碼，其次是我的模板類（和嵌套的迭代器類）的定義。

#include <iostream>
#include <fstream>
#include <cstdlib>
#include <string>
#include <vector>
#include "ValliHN.h"
using namespace std;

int main() {
    Valli<string> valli;

    valli.insert("K");
valli.insert("H");
valli.insert("N");
valli.insert("H");
valli.insert("J");

for (Valli<string>::iterator i = valli.begin(); i != valli.end(); i++)
    cout << *i << endl;

return 0;
}

模板類

#include"DList.h"
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdlib>

using std::cout;
using std::endl;
using std::cerr;
using std::vector;

template<typename I>
class Valli {

vector< DNode<I>* > va;
DList<I> lli;
size_t ratio;
friend class iterator;
friend class DList<I>;

public: 

class iterator {

  typename DList<I>::iterator list_iter;
  iterator(DNode<I>* node) 
   : list_iter(typename DList<I>::iterator(node)) { }
  friend class Valli<I>;
  friend class DList<I>;

public:
     I& operator*() const {
        return *list_iter;
     }

     iterator& operator++() {
        ++list_iter;
        return *this;
     }

     iterator operator++(int) {
        iterator* ret = this;
        ++list_iter;
        return *ret;
     }

     iterator& operator--() {
        --list_iter;
        return *this;
     }

     iterator operator--(int) {
        typename DList<I>::iterator ret = list_iter;
        --list_iter;
        return ret;
     }

     bool operator==(const iterator& rhs) const {
        return list_iter == rhs.list_iter;
     }

     bool operator!=(const iterator& rhs) const {
        return list_iter != rhs.list_iter;
     }

     DNode<I>* returnCurr() const {
        return list_iter.returnCurr();
     }
};

explicit Valli<I>(size_t ratio=4)
 : ratio(ratio),
  lli(DList<I>()),
  va(vector< DNode<I>* >()) { }

//   Valli<I>()
//    : Valli<I>(4) { }

~Valli<I>() {
//      delete[] va;
//      delete lli;
}

iterator insert(const I& item) {
   iterator pos = position(va, item);
   lli.insert(pos.returnCurr(), item);
   refresh(4);
   return --pos;
}

iterator find(const I& item) const {
  iterator start = iterator(va.at(binsearch(va, item)));
  iterator end = iterator(va.at(binsearch(va, item)+1));
  while(start != end) {
     if(*start = item) {
        return start;
     }
     else {
        ++start;
     }
  }
}
//   void erase(iterator itr) {}

iterator begin() const {
   lli.begin();
}

iterator end() const {
   lli.end();
}

private:
int binsearch(const vector< DNode<I>* > vec, const I& item) const {
  int left = 0;
  int right = vec.size()-1;
  while(left <= right) {
     int mid = (left+right)/2;
     iterator iter = iterator(vec.at(mid));
     if(item < *iter) {
        right = mid-1;
     }
     else if(item == *iter) {
        return mid;
     }
     else {
        left = mid+1;
     }
  }
  return left;
 }

iterator position(const vector< DNode<I>* > vec, const I& item) const {
  iterator start = iterator(vec.at(binsearch(vec, item)));
  iterator end = iterator(vec.at(binsearch(vec, item)+1));
  while(start != end) {
     if(*start < item) {
        ++start;
     }
     else {
        return start;
     }
  }

}

void refresh(size_t newRatio) {
  iterator iter = begin();
  int count = 0;
  va.clear();
  while(iter!=end()) {
     if(count % newRatio == 0) {
        va.push_back(iter.returnCurr());
     }
     //push_backing the last node - to be added
     iter++;
     count++;
  }
}

};

DList.h類與標准庫列表類非常相似。 您可以在我的代碼中看到問題嗎？ 另外，您能否告訴我，就良好的編程習慣和編碼方向的實現而言，我的代碼總體上是好是壞？

非常感謝你！

Answer 1

在我看來，您在第一個插入片段中的向量超出范圍。 插入通話位置，從而調用binsearch。 由於向量為空，因此binsearch返回0，然后位置調用vector.at（0）（和vector.at（1））。 由於向量為空，因此兩者均超出范圍錯誤。

我只是盯着代碼，所以我可能犯了一個錯誤。 確實，您應該使用調試器，並找出問題發生的確切位置。