public member function
<deque>

std::deque::insert

single element (1)
iterator insert (iterator position, const value_type& val);
fill (2)
    void insert (iterator position, size_type n, const value_type& val);
range (3)
template <class InputIterator>    void insert (iterator position, InputIterator first, InputIterator last);
single element (1)
iterator insert (const_iterator position, const value_type& val);
fill (2)
iterator insert (const_iterator position, size_type n, const value_type& val);
range (3)
template <class InputIterator>iterator insert (const_iterator position, InputIterator first, InputIterator last);
move (4)
iterator insert (const_iterator position, value_type&& val);
initializer list (5)
iterator insert (const_iterator position, initializer_list<value_type> il);
插入元素
deque 容器在指定 position 的元素之前插入新元素。

这有效地将容器的 size 增加了插入元素的数量。

双端队列被设计为在序列的末端或beginning高效地执行插入(和删除)。在其他位置的插入通常比在 listforward_list 容器中效率低。

参数决定了插入多少元素以及它们被初始化为哪个值。

参数

position
新元素被插入到容器中的位置。
iterator是成员类型,定义为指向元素的 随机访问迭代器 类型。
val
要复制(或移动)到插入元素的值。
成员类型value_type是容器中元素的类型,在 deque 中定义为其第一个模板参数(T).
n
要插入的元素数量。每个元素都将使用*val*的副本进行初始化。
成员类型size_type是一种无符号整型类型。
first, last
指定元素范围的迭代器。范围中元素的副本[first,last)将被插入到*position*(按相同顺序)。
请注意,范围包括 first 和 last 之间的所有元素,包括 first 指向的元素,但不包括 last 指向的元素。
函数模板参数InputIterator应为 输入迭代器 类型,指向的元素类型是value_type对象的类型的元素。
il
一个initializer_list对象。这些元素的副本将被插入到*position*(按相同顺序)。
这些对象是从初始化列表声明符自动构造的。
成员类型value_type是容器中元素的类型,在 deque 中定义为其第一个模板参数(T).

返回值

指向新插入的第一个元素的迭代器。

成员类型iterator随机访问迭代器 类型,指向元素。

)的别名。容器的 allocator 用于分配新元素所需的存储空间,这可能会在失败时抛出异常(对于默认的 allocator,会抛出bad_alloc如果分配请求不成功,则抛出)。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// inserting into a deque
#include <iostream>
#include <deque>
#include <vector>

int main ()
{
  std::deque<int> mydeque;

  // set some initial values:
  for (int i=1; i<6; i++) mydeque.push_back(i); // 1 2 3 4 5

  std::deque<int>::iterator it = mydeque.begin();
  ++it;

  it = mydeque.insert (it,10);                  // 1 10 2 3 4 5
  // "it" now points to the newly inserted 10

  mydeque.insert (it,2,20);                     // 1 20 20 10 2 3 4 5
  // "it" no longer valid!

  it = mydeque.begin()+2;

  std::vector<int> myvector (2,30);
  mydeque.insert (it,myvector.begin(),myvector.end());
                                                // 1 20 30 30 20 10 2 3 4 5

  std::cout << "mydeque contains:";
  for (it=mydeque.begin(); it!=mydeque.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}
输出
mydeque contains: 1 20 30 30 20 10 2 3 4 5


复杂度

线性复杂度与插入的元素数量(复制/移动构造)有关。此外,根据具体的库实现,可能还会加上 dequeposition 和序列任一端之间的元素数量的线性复杂度。

迭代器有效性

如果插入发生在序列的beginning或end,所有与该容器相关的迭代器都将失效,但指针和引用将保持有效,指向调用前它们所指向的相同元素。
如果插入发生在 deque 的任何其他位置,则所有与该容器相关的迭代器、指针和引用都将失效。

数据竞争

容器已被修改。
如果插入发生在序列的beginning或end,则不会访问任何包含的元素(尽管请参见上面的“迭代器有效性”)。
如果发生在其他任何地方,则并发访问元素是不安全的。

异常安全

如果操作在 beginend 处插入单个元素,则在发生异常时容器不会发生变化(强异常安全保证)。
否则,容器保证最终处于有效状态(基本异常安全保证)。
如果不支持具有适当参数的allocator_traits::construct进行元素构造,或者指定了无效的*position*或范围,则会导致*未定义行为*。

另见