构造函数

default (1)

 explicit forward_list (const allocator_type& alloc = allocator_type());

fill (2)

 explicit forward_list (size_type n);
 explicit forward_list (size_type n, const value_type& val,
                 const allocator_type& alloc = allocator_type());

range (3)

 template <class InputIterator>
 forward_list (InputIterator first, InputIterator last,
         const allocator_type& alloc = allocator_type());

copy (4)

 forward_list (const forward_list& fwdlst);
 forward_list (const forward_list& fwdlst, const allocator_type& alloc);

move (5)

 forward_list (forward_list&& fwdlst);
 forward_list (forward_list&& fwdlst, const allocator_type& alloc);

initializer list (6)

 forward_list (initializer_list<value_type> il,
       const allocator_type& alloc = allocator_type());

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


// forward_list constructors
#include <iostream>
#include <forward_list>

int main ()
{
  // constructors used in the same order as described above:

  std::forward_list<int> first;                      // default: empty
  std::forward_list<int> second (3,77);              // fill: 3 seventy-sevens
  std::forward_list<int> third (second.begin(), second.end()); // range initialization
  std::forward_list<int> fourth (third);            // copy constructor
  std::forward_list<int> fifth (std::move(fourth));  // move ctor. (fourth wasted)
  std::forward_list<int> sixth = {3, 52, 25, 90};    // initializer_list constructor

  std::cout << "first:" ; for (int& x: first)  std::cout << " " << x; std::cout << '\n';
  std::cout << "second:"; for (int& x: second) std::cout << " " << x; std::cout << '\n';
  std::cout << "third:";  for (int& x: third)  std::cout << " " << x; std::cout << '\n';
  std::cout << "fourth:"; for (int& x: fourth) std::cout << " " << x; std::cout << '\n';
  std::cout << "fifth:";  for (int& x: fifth)  std::cout << " " << x; std::cout << '\n';
  std::cout << "sixth:";  for (int& x: sixth)  std::cout << " " << x; std::cout << '\n';

  return 0;
}

赋值运算符

copy (1)

forward_list& operator= (const forward_list& fwdlst);

move (2)

forward_list& operator= (forward_list&& fwdlst);

initializer list(3)

forward_list& operator= (initializer_list<value_type> il);

 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


#include <iostream>
#include <forward_list>

template<class Container>
Container by_two (const Container& x) {
  Container temp(x); for (auto& x:temp) x*=2; return temp;
}

int main ()
{
  std::forward_list<int> first (4);      // 4 ints
  std::forward_list<int> second (3,5);   // 3 ints with value 5

  first = second;                        // copy assignment
  second = by_two(first);                // move assignment

  std::cout << "first: ";
  for (int& x : first) std::cout << ' ' << x;
  std::cout << '\n';

  std::cout << "second: ";
  for (int& x : second) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

迭代器

before_begin函数

  iterator before_begin（）noexcept;
const_iterator before_begin（）const noexcept;

将迭代器返回到开始之前

返回指向容器中第一个元素前的位置的迭代器。

返回的迭代器不应被解除引用：它是为了用作成员函数emplace_after，insert_after，erase_after或splice_after添加头结点的情况.

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


// forward_list::before_begin
#include <iostream>
#include <forward_list>

int main ()
{
  std::forward_list<int> mylist = {20, 30, 40, 50};

  mylist.insert_after ( mylist.before_begin(), 11 );

  std::cout << "mylist contains:";
  for ( int& x: mylist ) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

cbefore_begin函数

在启动前返回const_iterator

返回指向容器中第一个元素前的位置的const_iterator。

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <iostream>
#include <forward_list>

int main ()
{
  std::forward_list<int> mylist = {77, 2, 16};

  mylist.insert_after ( mylist.cbefore_begin(), 19 );

  std::cout << "mylist contains:";
  for ( int& x: mylist ) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

容量

元素访问

访问第一个元素

返回对forward_list容器中第一个元素的引用。

与成员forward_list :: begin不同，它将一个迭代器返回给同一个元素，该函数返回一个直接引用。

在空容器上调用此函数会导致未定义的行为。

reference front();
const_reference front() const;

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


// forward_list::front
#include <iostream>
#include <forward_list>

int main ()
{
  std::forward_list<int> mylist = {2, 16, 77};

  mylist.front() = 11;

  std::cout << "mylist now contains:";
  for ( int& x : mylist ) std::cout << ' ' << x;

  std::cout << '\n';

  return 0;
}

修改

assign函数

range (1)

 template <class InputIterator>
 	void assign (InputIterator first, InputIterator last);

fill (2)

 void assign (size_type n, const value_type& val);

initializer list (3)

 void assign (initializer_list<value_type> il);

分配内容

将新内容分配给forward_list容器，替换其当前内容，并相应地修改其大小。

在范围版本（1）中，新内容是以相同顺序在第一个和最后一个范围内的每个元素构造的元素。

在填充版本（2）中，新内容是n个元素，每个元素都初始化为一个val的副本。

在初始化器列表版本（3）中，新内容是以相同的顺序作为初始化器列表传递的值的副本。

在调用之前，容器中保存的任何元素都被销毁并被新构造的元素替换（元素的赋值不发生）。

如果存储有变化，则使用内部分配器（通过其特征）。它也用于摧毁所有现有元素，并构造新元素。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <iostream>
#include <forward_list>

int main ()
{
  std::forward_list<int> first;
  std::forward_list<int> second;

  first.assign (4,15);                           // 15 15 15 15

  second.assign (first.begin(),first.end());     // 15 15 15 15

  first.assign ( {77, 2, 16} );                  // 77 2 16

  std::cout << "first contains: ";
  for (int& x : first) std::cout << ' ' << x;
  std::cout << '\n';

  std::cout << "second contains: ";
  for (int& x : second) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

emplace_front函数

template <class... Args>
  void emplace_front (Args&&... args);

开始构造和插入元素

在forward_list的开头插入一个新的元素，就在它的当前第一个元素之前。这个新元素是使用args作为构造的参数来构建的。

这有效地将容器尺寸增加了一个。

存在类似的成员函数push_front，它将现有对象复制或移动到容器中。

push_front函数

void push_front (const value_type& val);
void push_front (value_type&& val);

开始位置插入元素

在forward_list的开头插入一个新的元素，就在它的当前第一个元素之前。val的内容被复制（或移动）到插入的元素。

这有效地将容器尺寸增加了一个。

存在类似的成员函数emplace_front，它直接构建插入的元素对象，而不执行任何复制或移动操作。

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


// forward_list::push_front
#include <iostream>
#include <forward_list>
using namespace std;

int main ()
{
  forward_list<int> mylist = {77, 2, 16};
  mylist.push_front (19);
  mylist.push_front (34);

  std::cout << "mylist contains:";
  for (int& x: mylist) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

pop_front函数

void pop_front();

删除第一个元素

删除forward_list容器中的第一个元素，将其大小减少一个。

这会破坏已删除的元素。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <iostream>
#include <forward_list>

int main ()
{
  std::forward_list<int> mylist = {10, 20, 30, 40};

  std::cout << "Popping out the elements in mylist:";
  while (!mylist.empty())
  {
    std::cout << ' ' << mylist.front();
    mylist.pop_front();
  }

  std::cout << '\n';

  return 0;
}

emplace_after函数

template <class... Args>
	iterator emplace_after (const_iterator 	position, Args&&... args);

构造和插入元素

该容器通过在元件之后插入一个新元素扩展位置。这个新元素是使用args作为构造的参数来构建的。

与其他标准序列容器不同，list和forward_list对象被专门设计为即使在序列中间也可以有效地插入和移除任何位置的元素。

要在forward_list开头放置元素，请使用成员函数emplace_front，或者使用before_begin作为position来调用此函数。

元素通过使用args参数调用allocator_traits :: construct来就地构建。存在类似的成员函数insert_after，它将现有对象复制或移动到容器中。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


// forward_list::emplace_after
#include <iostream>
#include <forward_list>

int main ()
{
  std::forward_list< std::pair<int,char> > mylist;
  auto it = mylist.before_begin();

  it = mylist.emplace_after ( it, 100, 'x' );
  it = mylist.emplace_after ( it, 200, 'y' );
  it = mylist.emplace_after ( it, 300, 'z' );

  std::cout << "mylist contains:";
  for (auto& x: mylist)
    std::cout << " (" << x.first << "," << x.second << ")";

  std::cout << '\n';
  return 0;
}

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

插入元素

通过在元素位置之后插入新元素来扩展容器。

与其他标准序列容器不同，list和forward_list对象被专门设计为即使在序列中间也可以有效地插入和移除任何位置的元素。

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

 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


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

erase_after函数

iterator erase_after (const_iterator position);

iterator erase_after (const_iterator position, const_iterator last);

删除元素

从forward_list容器中移除单个元素（位置之后）或一系列元素（（position，last））。

与其他标准序列容器不同，list和forward_list对象被专门设计为即使在序列中间也可以有效地插入和移除任何位置的元素。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <iostream>
#include <forward_list>

int main ()
{
  std::forward_list<int> mylist = {10, 20, 30, 40, 50};

                                            // 10 20 30 40 50
  auto it = mylist.begin();                 // ^

  it = mylist.erase_after(it);              // 10 30 40 50
                                            //    ^
  it = mylist.erase_after(it,mylist.end()); // 10 30
                                            //       ^

  std::cout << "mylist contains:";
  for (int& x: mylist) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

swap函数

void swap (forward_list& fwdlst);

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <iostream>
#include <forward_list>

int main ()
{
  std::forward_list<int> first = {10, 20, 30};
  std::forward_list<int> second = {100, 200};
  std::forward_list<int>::iterator it;

  first.swap(second);

  std::cout << "first contains:";
  for (int& x: first) std::cout << ' ' << x;
  std::cout << '\n';

  std::cout << "second contains:";
  for (int& x: second) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

resize函数

void resize（size_type n）;
void resize（size_type n，const value_type＆val）;

改变大小

调整容器的大小以包含n个元素。

如果n小于容器中当前的元素数量，则内容将被修剪为仅包含其前n个元素，删除其他剩余元素。

如果n大于容器中当前的元素数量，则通过根据需要插入尽可能多的元素来扩展内容，以达到n个元素的大小。如果指定了val，则新元素将被初始化为val的副本，否则它们被初始化。

请注意，此功能通过插入或删除其中的元素来更改容器的实际内容。

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <iostream>
#include <forward_list>

int main ()
{
  std::forward_list<int> mylist = {10, 20, 30, 40, 50};
                                // 10 20 30 40 50
  mylist.resize(3);             // 10 20 30
  mylist.resize(5,100);         // 10 20 30 100 100

  std::cout << "mylist contains:";
  for (int& x: mylist) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

clear函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <iostream>
#include <forward_list>

int main ()
{
  std::forward_list<int> mylist = { 10, 20, 30 };

  std::cout << "mylist contains:";
  for (int& x: mylist) std::cout << ' ' << x;
  std::cout << '\n';

  mylist.clear();
  mylist.insert_after( mylist.before_begin(), {100, 200} );

  std::cout << "mylist contains:";
  for (int& x: mylist) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

操作

splice_after函数

entire list (1)

 void splice_after (const_iterator position, forward_list& fwdlst);
 void splice_after (const_iterator position, forward_list&& fwdlst);

single element (2)

 void splice_after (const_iterator position, forward_list& fwdlst, const_iterator i);
 void splice_after (const_iterator position, forward_list&& fwdlst, const_iterator i);

element range (3)

 void splice_after (const_iterator position, forward_list& fwdlst,
            const_iterator first, const_iterator last);
 void splice_after (const_iterator position, forward_list&& fwdlst,
            const_iterator first, const_iterator last);

从另一个forward_list传输元素

将元素从fwdlst转移到容器中，在元素指向位置之后插入它们。

这有效地将这些元素插入到容器中，并从fwdlst中删除它们，从而改变了两个容器的大小。操作不涉及构造或破坏任何元素。它们被转移，无论fwdlst是一个左值还是一个右值，还是value_type是否支持移动构造。

示例:

 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
35


// forward_list::splice_after
#include <iostream>
#include <forward_list>

int main ()
{
  std::forward_list<int> first = { 1, 2, 3 };
  std::forward_list<int> second = { 10, 20, 30 };

  auto it = first.begin();  // points to the 1

  first.splice_after ( first.before_begin(), second );
                          // first: 10 20 30 1 2 3
                          // second: (empty)
                          // "it" still points to the 1 (now first's 4th element)

  second.splice_after ( second.before_begin(), first, first.begin(), it);
                          // first: 10 1 2 3
                          // second: 20 30

  first.splice_after ( first.before_begin(), second, second.begin() );
                          // first: 30 10 1 2 3
                          // second: 20
                          // * notice that what is moved is AFTER the iterator

  std::cout << "first contains:";
  for (int& x: first) std::cout << " " << x;
  std::cout << std::endl;

  std::cout << "second contains:";
  for (int& x: second) std::cout << " " << x;
  std::cout << std::endl;

  return 0;
}

remove函数

void remove（const value_type＆val）;

删除具有特定值的元素

从容器中删除所有与val相等的元素。这调用这些对象的析构函数，并通过删除元素的数量减少容器大小。

与成员函数forward_list :: erase_after不同，它通过它们的位置（使用迭代器）擦除元素，该函数（forward_list :: remove）根据其值删除元素。

存在一个类似的函数：forward_list :: remove_if，它允许除了等式比较之外的条件来确定元素是否被删除。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


// remove from forward_list
#include <iostream>
#include <forward_list>

int main ()
{
  std::forward_list<int> mylist = {10, 20, 30, 40, 30, 20, 10};

  mylist.remove(20);

  std::cout << "mylist contains:";
  for (int& x: mylist) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

remove_if函数

template void remove_if (Predicate pred);

示例:

 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


// forward_list::remove_if
#include <iostream>
#include <forward_list>

// a predicate implemented as a function:
bool single_digit (const int& value) { return (value<10); }

// a predicate implemented as a class:
class is_odd_class
{
public:
  bool operator() (const int& value) {return (value%2)==1; }
} is_odd_object;

int main ()
{
  std::forward_list<int> mylist = {7, 80, 7, 15, 85, 52, 6};

  mylist.remove_if (single_digit);      // 80 15 85 52

  mylist.remove_if (is_odd_object);     // 80 52

  std::cout << "mylist contains:";
  for (int& x: mylist) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

unique函数

(1)

void unique();

(2)

template <class BinaryPredicate>
  void unique (BinaryPredicate binary_pred);

删除重复的值

 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
35
36
37
38
39


// forward_list::unique
#include <iostream>
#include <cmath>
#include <forward_list>

// a binary predicate implemented as a function:
bool same_integral_part (double first, double second)
{ return ( int(first)==int(second) ); }

// a binary predicate implemented as a class:
class is_near_class
{
public:
  bool operator() (double first, double second)
  { return (fabs(first-second)<5.0); }
} is_near_object;

int main ()
{

  std::forward_list<double> mylist = { 15.2, 73.0, 3.14, 15.85, 69.5,
                                       73.0, 3.99, 15.2, 69.2,  18.5 };

  mylist.sort();                       //   3.14,  3.99, 15.2, 15.2, 15.85
                                       //  18.5,  69.2,  69.5, 73.0, 73.0

  mylist.unique();                     //   3.14,  3.99, 15.2, 15.85
                                       //  18.5,  69.2,  69.5, 73.0

  mylist.unique (same_integral_part);  //  3.14, 15.2, 18.5,  69.2, 73.0

  mylist.unique (is_near_object);      //  3.14, 15.2, 69.2

  std::cout << "mylist contains:";
  for (double& x: mylist) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

merge函数

(1)

  void merge (forward_list& fwdlst);
  void merge (forward_list&& fwdlst);

(2)

template <class Compare>
  void merge (forward_list& fwdlst, Compare comp);
template <class Compare>
  void merge (forward_list&& fwdlst, Compare comp);

示例:

 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


// forward_list::merge
#include <iostream>
#include <forward_list>
#include <functional>

int main ()
{
  std::forward_list<double> first = {4.2, 2.9, 3.1};
  std::forward_list<double> second = {1.4, 7.7, 3.1};
  std::forward_list<double> third = {6.2, 3.7, 7.1};

  first.sort();
  second.sort();
  first.merge(second);

  std::cout << "first contains:";
  for (double& x: first) std::cout << " " << x;
  std::cout << std::endl;

  first.sort (std::greater<double>());
  third.sort (std::greater<double>());
  first.merge (third, std::greater<double>());

  std::cout << "first contains:";
  for (double& x: first) std::cout << " " << x;
  std::cout << std::endl;

  return 0;
}

sort函数

(1)

void sort();

(2)

template <class Compare>
  void sort (Compare comp);

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <iostream>
#include <forward_list>
#include <functional>

int main ()
{
  std::forward_list<int> mylist = {22, 13, 5, 40, 90, 62, 31};

  mylist.sort();

  std::cout << "default sort (operator<):";
  for (int& x: mylist) std::cout << ' ' << x;
  std::cout << '\n';

  mylist.sort(std::greater<int>());

  std::cout << "sort with std::greater():";
  for (int& x: mylist) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

reverse函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


// reversing forward_list
#include <iostream>
#include <forward_list>

int main ()
{
  std::forward_list<int> mylist = {10, 20, 30, 40};

  mylist.reverse();

  std::cout << "mylist contains:";
  for (int& x: mylist) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

分配器

allocator_type get_allocator() const noexcept;

forward_list操作总结

文章目录

构造函数

赋值运算符

迭代器

before_begin函数

cbefore_begin函数

容量

元素访问

修改

assign函数

emplace_front函数

push_front函数

pop_front函数

emplace_after函数

insert_after函数

erase_after函数

swap函数

resize函数

clear函数

操作

splice_after函数

remove函数

remove_if函数

unique函数

merge函数

sort函数

reverse函数

分配器

重载