C++

参考

<forward_list>

forward_list

public member function
<forward_list>

std::forward_list::insert_after

(1)
iterator insert_after ( const_iterator position, const value_type& val );
(2)
iterator insert_after ( const_iterator position, value_type&& val );
(3)
iterator insert_after ( const_iterator position, size_type n, const value_type& val );
(4)
template <class InputIterator>  iterator insert_after ( const_iterator position, InputIterator first, InputIterator last );
(5)
iterator insert_after ( const_iterator position, initializer_list<value_type> il );
插入元素
该容器通过在position指定元素之后插入新元素来扩展。

这会有效地将容器大小增加插入元素的数量。

与其他标准序列容器不同，list和forward_list容器专门设计用于在任何位置（即使在序列中间）高效地插入和删除元素。

存在一个类似的成员函数 emplace_after，它直接在原地构造插入的元素对象，而无需执行任何复制或移动操作。

参数决定了插入多少元素以及如何初始化它们的值。

参数

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

返回值

指向新插入的最后一个元素的迭代器，如果未插入元素，则为position。

成员类型iterator是一种指向元素的前向迭代器类型。

新元素的存储使用allocator_traits<allocator_type>::construct()分配，这在失败时可能会抛出异常（对于默认的 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
 
// forward_list::insert_after
#include <iostream>
#include <array>
#include <forward_list>

int main ()
{
  std::array<int,3> myarray = { 11, 22, 33 };
  std::forward_list<int> mylist;
  std::forward_list<int>::iterator it;

  it = mylist.insert_after ( mylist.before_begin(), 10 );          // 10
                                                                   //  ^  <- it
  it = mylist.insert_after ( it, 2, 20 );                          // 10 20 20
                                                                   //        ^
  it = mylist.insert_after ( it, myarray.begin(), myarray.end() ); // 10 20 20 11 22 33
                                                                   //                 ^
  it = mylist.begin();                                             //  ^
  it = mylist.insert_after ( it, {1,2,3} );                        // 10 1 2 3 20 20 11 22 33
                                                                   //        ^

  std::cout << "mylist contains:";
  for (int& x: mylist) std::cout << ' ' << x;
  std::cout << '\n';
  return 0;
}
输出
mylist contains: 10 1 2 3 20 20 11 22 33


复杂度

线性复杂度，与插入的元素数量（复制/移动构造）成正比。

迭代器有效性

没有变化。

数据竞争

容器被修改。
没有访问包含的元素。同时访问或修改不同的元素是安全的，但迭代包含position的范围则不是。

异常安全

强保证：如果抛出异常，容器没有发生变化。
如果不支持具有适当参数的allocator_traits::construct进行元素构造，或者指定了无效的*position*或范围，则会导致*未定义行为*。

另见

forward_list::push_front
在起始位置插入元素 (公开成员函数)
forward_list::emplace_after
构造并插入元素 (公开成员函数)
forward_list::splice_after
从另一个 forward_list 转移元素 (公开成员函数)
forward_list::merge
合并已排序的列表 (公开成员函数)
forward_list::erase_after
擦除元素 (公开成员函数)