簡介

在頭文件 中定義

namespace std 
{
    template  >
class forward_forward_list;
}

單向列表是一個容器，支持在其任何地方快速插入和刪除元素，不支持快速的隨機訪問。它被實現為單向鏈表，和C中它的實現相比，基本上不會有任何開銷。
當不需要雙向迭代的時候，與forward_list相比，該容器具有更高的空間利用率。
插入和刪除操作不會使指向其他元素指針、引用和迭代器失效。

forward_list操作

構造、復制與析構

forward_list c //默認構造函數；創建一個空forward_list

forward_list c(c2) //復制構造函數；創建一個新的forward_list作為c2的副本（所有元素都被復制）

forward_list c = c2 //復制構造函數；創建一個新的forward_list作為c2的副本（所有元素都被復制）

forward_list c(rv) //移動構造函數；使用右值對象rv創建一個新forward_list

forward_list c = rv //移動構造函數；使用右值對象rv創建一個新forward_list

forward_list c(n) //使用默認構造函數創建含有n個元素的forward_list

forward_list c(n,elem) //創建一個forward_list，並使用n個elem進行初始化

forward_list c(beg,end) //創建一個forward_list，並使用beg到end范圍內的值進行初始化

forward_list c(initlist) //創建一個forward_list，並使用初始化列表進行初始化

forward_list c = initlist //創建一個forward_list，並使用初始化列表進行初始化

c.~forward_list() //銷毀所有元素並釋放內存

非變動性操作

c.empty() //判斷容器是否為空

c.max_size() //返回可容納的元素最大數量

c1 == c2 //判斷c1與c2是否相等

c1 != c2 //判斷c1與c2是否不相等，等同於!(c1==c2)

c1 < c2 //判斷c1是否小於c2

c1 > c2 //判斷c1是否大於c2

c1 <= c2 //判斷c1是否小於等於c2

c1 >= c2 //判斷c1是否大於等於c2

賦值

c = c2 //將c2所有元素賦值給c

c = rv //將右值對象rv的所有元素移動賦值給c

c = initlist //使用初始化列表進行賦值

c.assign(initlist) //使用初始化列表進行賦值

c.assign(n,elem) //使用n個elem元素進行賦值

c.assign(beg,end) //使用beg到end范圍內的元素進行賦值

c1.swap(c2) //交換c1和c2的數

swap(c1,c2) //交換c1和c2的數

元素存取

c.front() //返回第一個元素，不檢查第一個元素是否存在

迭代器相關函數

c.begin() //返回一個雙向迭代器，指向第一個元素

c.end() //返回一個雙向迭代器，指向最後一個元素

c.cbegin() //返回一個雙向常迭代器，指向第一個元素

c.cend() //返回一個雙向常迭代器，指向最後一個元素

c.before_begin() //返回一個前向迭代器，指向第一個元素之前的位置

c.cbefore_begin() //返回一個前向常迭代器，指向第一個元素之前的位置

插入和移除元素

c.push_front(elem) //在頭部添加一個elem副本

c.pop_front() //移除頭部元素（但不回傳）

c.insert_after(pos,elem) //在迭代器位置之後插入一個elem副本，並返回新元素的位置

c.insert_after(pos,n,elem) //在迭代器位置之後插入n個elem副本，並返回第一個新元素的位置；若無新插入值，返回原位置

c.insert_after(pos,beg,end) //在迭代器位置之後插入范圍beg到end的所有元素的副本，並返回第一個新元素的位置；若無新插入值，返回原位置

c.insert_after(pos,initforward_list) //在迭代器位置之後插入初始化列表的所有元素的副本，並返回第一個新元素的位置；若無新插入值，返回原位置

c.emplace_after(pos,args...) //在迭代器位置之後插入一個使用args初始化的元素副本，並返回新元素的位置

c.emplace_front(args...) //在頭部添加一個使用args初始化的元素副本，無返回值

c.erase_after(pos) //移除迭代器位置的元素，無返回值

c.erase_after(beg,end) //移除beg到end范圍內的所有元素，無返回值

c.remove(val) //移除所有值為val的元素

c.remove_if(op) //移除所有滿足op條件的元素

c.resize(num) //將元素數量設為num（如果size()增大，多出來的元素使用默認構造函數創建）

c.resize(num,elem) //將元素數量設為num（如果size()增大，多出來的元素都是elem的副本）

c.clear() //移除所以元素，清空容器

特殊修改操作

c.unique() //若存在相鄰而數值相等的元素，移除重復元素

c.unique(op) //若存在相鄰而數值相等的元素，且滿足op條件時，移除重復元素

c.splice_after(pos,c2) //將c2內的所有元素轉移到c1內pos所指的位置之後

c.splice_after(pos,c2,c2pos) //將c2內c2pos之後的元素轉移到c1內pos所指的位置之後

c.splice_after(pos,c2,c2beg,c2end) //將c2內從c2beg到c2end區間內的所有元素轉移到c1內pos所指的位置之後

c.sort() //以operator<為准則，對所有元素排序

c.sort(op)  //以op為准則，對所有元素排序

c.merge(c2) //假設c1和c2都包含已序元素，將c2的全部元素轉移到c1.並保證合並後的forward_list仍為已序

c.merge(c2,op) //假設c1和c2都包含op原則下已序元素，將c2的全部元素轉移到c1.並保證合並後的forward_list在op原則下仍為已序

c.reverse() //將所有元素反序

栗子

#include 
#include 
#include 
#include 
#include 

using namespace std;

void printLists (const string& s, const forward_list& l1,
                 const forward_list& l2)
{
    cout << s << endl;
    cout << " list1: ";
    copy (l1.cbegin(), l1.cend(), ostream_iterator(cout," "));
    cout << endl << " list2: ";
    copy (l2.cbegin(), l2.cend(), ostream_iterator(cout," "));
    cout << endl;
}

int main()
{
    //創建兩個前向列表
    forward_list list1 = { 1, 2, 3, 4 };
    forward_list list2 = { 77, 88, 99 };
    printLists ("initial:", list1, list2);

    //在list2頭部插入6個新元素
    list2.insert_after(list2.before_begin(),99);
    list2.push_front(10);
    list2.insert_after(list2.before_begin(), {10,11,12,13} );
    printLists ("6 new elems:", list1, list2);

    //在list1頭部插入list2全部元素
    list1.insert_after(list1.before_begin(),
                       list2.begin(),list2.end());
    printLists ("list2 into list1:", list1, list2);

    //刪除list2的第二個元素，刪除list2中值為99的元素後面的所有元素
    list2.erase_after(list2.begin());
    list2.erase_after(find(list2.begin(),list2.end(),
                           99),
                      list2.end());
    printLists ("delete 2nd and after 99:", list1, list2);

    //對list1排序,並把list1賦值給list2，對list2去重
    list1.sort();
    list2 = list1;
    list2.unique();
    printLists ("sorted and unique:", list1, list2);

    //把已序的list2合並到list1中
    list1.merge(list2);
    printLists ("merged:", list1, list2);

    return 0;
}

}

輸出

initial:
list1: 1 2 3 4
list2: 77 88 99
6 new elems:
list1: 1 2 3 4
list2: 10 11 12 13 10 99 77 88 99
list2 into list1:
list1: 10 11 12 13 10 99 77 88 99 1 2 3 4
list2: 10 11 12 13 10 99 77 88 99
delete 2nd and after 99:
list1: 10 11 12 13 10 99 77 88 99 1 2 3 4
list2: 10 12 13 10 99
sorted and unique:
list1: 1 2 3 4 10 10 11 12 13 77 88 99 99
list2: 1 2 3 4 10 11 12 13 77 88 99
merged:
list1: 1 1 2 2 3 3 4 4 10 10 10 11 11 12 12 13 13 77 77 88 88 99 99 99
list2: