C++的Push_Front Pop_Back矢量

Question

我試圖保留一個命令的矢量，以便它保持最近的10個。我有一個push_back和一個pop_back，但是如何刪除最舊的，而不移動for循環中的所有內容？擦除是唯一的方法來做到這一點？

Answer 1

使用std::deque這是一個向量類容器，很好地在兩端刪除和插入。

Answer 2

如果你適合使用升壓，我建議你看circular_buffer，這與這個確切的問題非常有效的處理（這避免了移動體周圍不必要的，相反只是操縱一兩個指針）：

// Create a circular buffer with a capacity for 3 integers. 
boost::circular_buffer<int> cb(3); 

// Insert threee elements into the buffer. 
cb.push_back(1); 
cb.push_back(2); 
cb.push_back(3); 
cb.push_back(4); 
cb.push_back(5); 

最後兩個操作只是簡單地覆蓋前兩個元素。

Answer 3

在一個向量上寫一個包裝來給自己一個循環緩衝區。事情是這樣的：

include <vector> 

/** 

    Circular vector wrapper 

    When the vector is full, old data is overwritten 

*/ 
class cCircularVector 
{ 
public: 

    // An iterator that points to the physical begining of the vector 
    typedef std::vector<short>::iterator iterator; 
    iterator begin() { return myVector.begin(); } 
    iterator end() { return myVector.end(); } 

    // The size (capacity) of the vector 
    int size() { return (int) myVector.size(); } 

    void clear() { myVector.clear(); next = 0; } 

    void resize(int s) { myVector.resize(s); } 

    // Constructor, specifying the capacity 
    cCircularVector(int capacity) 
    : next(0) 
    { 
     myVector.resize(capacity); 
    } 

    // Add new data, over-writing oldest if full 
    void push_back(short v) 
    { 
     myVector[ next] = v; 
     advance(); 
    } 

    int getNext() 
    { 
     return next; 
    } 

private: 

    std::vector<short> myVector; 
    int next; 

    void advance() 
    { 
     next++; 
     if(next == (int)myVector.size()) 
      next = 0; 

    } 
}; 

Answer 4

什麼是這樣的：

http://ideone.com/SLSNpc

注：這只是一個基礎，你還需要努力一下就可以了。這個想法很容易使用，因爲它有自己的迭代器，它會給你你想要的輸出。正如你所看到的，插入的最後一個值是首先顯示的值，我猜測它是你想要的值。

#include <iostream> 
#include <vector> 

template<class T, size_t MaxSize> 
class TopN 
{ 
public: 
    void push_back(T v) 
    { 
     if (m_vector.size() < MaxSize) 
      m_vector.push_back(v); 
     else 
      m_vector[m_pos] = v; 

     if (++m_pos == MaxSize) 
      m_pos = 0; 
    } 

    class DummyIterator 
    { 
    public: 
     TopN &r; // a direct reference to our boss. 
     int p, m; // m: how many elements we can pull from vector, p: position of the cursor. 

     DummyIterator(TopN& t) : r(t), p(t.m_pos), m(t.m_vector.size()){} 

     operator bool() const { return (m > 0); } 

     T& operator *() 
     { 
      static T e = 0; // this could be removed 
      if (m <= 0) // if someone tries to extract data from an empty vector 
       return e; // instead of throwing an error, we return a dummy value 

      m--; 

      if (--p < 0) 
       p = MaxSize - 1; 

      return r.m_vector[p]; 
     } 
    }; 

    decltype(auto) begin() { return m_vector.begin(); } 
    decltype(auto) end() { return m_vector.end(); } 

    DummyIterator get_dummy_iterator() 
    { 
     return DummyIterator(*this); 
    } 
private: 
    std::vector<T> m_vector; 
    int m_pos = 0; 
}; 

template<typename T, size_t S> 
void show(TopN<T,S>& t) 
{ 
    for (auto it = t.get_dummy_iterator(); it;) 
     std::cout << *it << '\t'; 

    std::cout << std::endl; 
}; 

int main(int argc, char* argv[]) 
{ 
    TopN<int,10> top10; 
    for (int i = 1; i <= 10; i++) 
     top10.push_back(5 * i); 

    show(top10); 

    top10.push_back(60); 
    show(top10); 

    top10.push_back(65); 
    show(top10); 

    return 0; 
}