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; 
}