C++ 如何使用C+有效地将一系列项插入到中间的std:：deque中+；03?

我正在使用C++03将一系列整数插入

std:：deque

。在

deque

中插入一次的唯一方法是使用采用位置、计数和值的重载，或者使用位置、开始输入迭代器和结束输入迭代器。如果我可以使用后者，我会这样做：

#include <deque>
#include <boost/iterator/counting_iterator.hpp>

void
insertRecent(const int begin,
             const int end, // Assumes end >= begin
             std::deque<int> &_recent,
             std::deque<int>::iterator insertionPoint)
{
  _recent.insert(insertionPoint,
                 boost::counting_iterator<int>(begin),
                 boost::counting_iterator<int>(end));
}

---

我相信这种方法在

（end-begin）

范围内是线性的，在距离

（\u recent.end（）-insertionPoint）

的距离上是线性的。我认为这是我在这里能做的最好的事情，对吗？

您可以制作自己的计数迭代器：

class my_int_iterator {
    int v_;
public:
    my_int_iterator (int v = 0) : v_(v) {}
    int operator * () const { return v_; }
    my_int_iterator & operator ++ () { ++v_; return *this; }
    bool operator != (my_int_iterator mii) const { return v_ != mii.v_; }

    typedef std::input_iterator_tag iterator_category;
    typedef int value_type;
    typedef void difference_type;
    typedef void pointer;
    typedef void reference;
};

void
insertRecent(const int begin,
             const int end, // Assumes end >= begin
             std::deque<int> &_recent,
             std::deque<int>::iterator insertionPoint)
{
  _recent.insert(insertionPoint,
                 my_int_iterator(begin),
                 my_int_iterator(end));
}

class my\u int\u迭代器{
INTV_；
公众：
my_int_迭代器（intv=0）：v_（v）{}
int运算符*（）常量{return v_；}
my_int_迭代器和运算符++（）{++v_u；返回*this；}
布尔运算符！=（my_int_迭代器mii）const{return v_！=mii.v_；}
typedef std:：input_iterator_tag iterator_category；
typedef int value_type；
typedef void difference_type；
typedef空指针；
类型定义无效引用；
};
无效的
insertRecent（const int begin，
const int end，//假设end>=begin
std：：德克和(最近)，
std:：deque:：迭代器插入点）
{
_最近的。插入（插入点，
my_int_迭代器（begin），
my_int_迭代器（end））；
}

这里对数据结构的选择提出了疑问。在一个数据结构上进行插入似乎有点难闻，因为数据结构在生活中的目的是保持数据的顺序。@NicolasHolthaus我的数据是有序的。

class my_int_iterator {
    int v_;
public:
    my_int_iterator (int v = 0) : v_(v) {}
    int operator * () const { return v_; }
    my_int_iterator & operator ++ () { ++v_; return *this; }
    bool operator != (my_int_iterator mii) const { return v_ != mii.v_; }

    typedef std::input_iterator_tag iterator_category;
    typedef int value_type;
    typedef void difference_type;
    typedef void pointer;
    typedef void reference;
};

void
insertRecent(const int begin,
             const int end, // Assumes end >= begin
             std::deque<int> &_recent,
             std::deque<int>::iterator insertionPoint)
{
  _recent.insert(insertionPoint,
                 my_int_iterator(begin),
                 my_int_iterator(end));
}