C++中STL STD::list使用说明

stl list使用说明
    
    使用标准的std::list进行容器数据处理时，操作比较底层。我们可以，减少引用标准MFC标准库，减少系统的大小，但同时也存在有不方便的操作之处，这里同大家分享一些使用心得……
    
    在使用std::list<>链表时，难免会对数据进行添加删除操作。而遍历链表则有两种方式：通过索引访问，象数组一样处理；通过std::list<>::iterator链表遍历器进行访问
    
    list
    
    STL 中的list 就是一 双向链表，可高效地进行插入删除元素。
    
    list不支持随机访问。所以没有 at（pos）和operator[].
    
    list 对象list1, list2 分别有元素list1（1,2,3），list2（4,5,6） .list< int>::iterator it;
    
    list成员
    
    说明
    
    constructor
    
    构造函数
    
    destructor
    
    析构函数
    
    operator=
    
    赋值重载运算符
    
    assign
    
    分配值
    
    front
    
    返回第一个元素的引用
    
    back
    
    返回最后一元素的引用
    
    begin
    
    返回第一个元素的指针（iterator）
    
    end
    
    返回最后一个元素的下一位置的指针
    
    rbegin
    
    返回链表最后一元素的后向指针（reverse_iterator or const）
    
    rend
    
    返回链表第一元素的下一位置的后向指针
    
    push_back
    
    增加一元素到链表尾
    
    push_front
    
    增加一元素到链表头
    
    pop_back
    
    pop_back（）删除链表尾的一个元素
    
    pop_front
    
    删除链表头的一元素
    
    clear
    
    删除所有元素
    
    erase
    
    删除一个元素或一个区域的元素（两个重载）
    
    remove
    
    删除链表中匹配值的元素（匹配元素全部删除）
    
    remove_if
    
    删除条件满足的元素（遍历一次链表），参数为自定义的回调函数
    
    empty
    
    判断是否链表为空
    
    max_size
    
    返回链表最大可能长度
    
    size
    
    返回链表中元素个数
    
    resize
    
    重新定义链表长度（两重载函数）
    
    reverse
    
    反转链表
    
    sort
    
    对链表排序，默认升序
    
    merge
    
    合并两个有序链表并使之有序
    
    splice
    
    对两个链表进行结合（三个重载函数） 结合后第二个链表清空
    
    insert
    
    在指定位置插入一个或多个元素（三个重载函数）
    
    swap
    
    交换两个链表（两个重载）
    
    unique
    
    删除相邻重复元素
    
    1.list 构造函数
    
    list <int > L0 ;        // 空链表
    
    list <int > L1 （9）；    // 建一个含个默认值是的元素的链表
    
    list <int > L2 （5,1）； // 建一个含个元素的链表，值都是
    
    list <int > L3 （L2 ）；  // 建一个L 2 的 copy 链表
    
    list <int > L4 （L0 .begin （）， L0 .end （））；// 建一个含 L0 一个区域的元素
    
    2. assign（） 分配值，有两个重载
    
    L1. assign （ 4,3）；                                // L1（3,3,3,3）
    
    L1. assign（ ++list1.beging（）， list2.end（））；   // L 1（2,3）
    
    3 . operator= 赋值重载运算符
    
    L1 = list1;   // L1 （1,2,3）
    
    4.   front（） 返回第一个元素的引用
    
    int nRet = list1.front（）    // nRet = 1
    
    5.   back（） 返回最后一 元素的引用
    
    int nRet = list1.back（）     // nRet = 3
    
    6.   begin（） 返回第一个元素的指针（iterator）
    
    it = list1.begin（）；    // *it = 1
    
    7.     end（） 返回最后一个元素的 下一位置 的指针（list 为空时end（）=begin（））
    
    it = list1.end（）；
    
    --it;                       // *it = 3
    
    8.rbegin（） 返回链表最后一 元素的后向指针（reverse_iterator or const）
    
    list <int >::reverse_iterator it = list1 .rbegin （）；  // *it = 3
    
    9.      rend（） 返回链表第一元素的 下一位置 的后向指针
    
    list< int>::reverse_iterator it = list1 .rend（）； // *（--riter） = 1
    
    10.push_back（） 增加一 元素到链表尾
    
    list1.push_back（ 4）       // list1（1,2,3, 4 ）
    
    11.   push_front（） 增加一 元素到链表头
    
    list1.push_front（ 4）      // list1（ 4 ,1,2,3）
    
    12.   pop_back（） 删除链表尾的一个元素
    
    list1.pop_back（ ）          // list1（1,2）
    
    13.pop_front（） 删除链表头 的一 元素
    
    list1.pop_front（）           // list1（2,3）
    
    14 .clear（） 删除所有元素
    
    list1.clear（）；   // list1 空了，list1.size（） = 0
    
    15.erase（） 删除 一个元素 或 一个区域的元素 （ 两个重载函数）
    
    list1.erase（ list1.begin（））；                // list1（2,3）
    
    list1.erase（ ++list1.begin（），list1.end（））； // list1（1）
    
    16.       remove（） 删除链表中匹配值 的元素（ 匹配元素全部删除）
    
    list 对象L1（ 4 ,3,5,1, 4 ）
    
    L1.remove（ 4）；               // L1（3,5,1）；
    
    17.remove_if（） 删除条件满足的元素（ 遍历一次链表） ,参数为自定义的回调函数
    
    // 小于2 的值删除
    
    bool myFun （const int & value ） { return （value < 2）； }
    
    list1.remove_if（ myFun ）；    // list1（3）
    
    18.empty（） 判断是否链表为空
    
    bool bRet = L1.empty（）； // 若L1 为空，bRet = true ,否则bRet = false .
    
    19.max_size（） 返回链表最大可能长度
    
    list <int >::size_type nMax = list1 .max_size （）；// nMax = 1073741823
    
    20 .size（） 返回链表中元素个数
    
    list< int>::size_type nRet = list1.size（）；      // nRet = 3
    
    21.resize（） 重新定义链表长度（ 两重载函数）
    
    list1.resize（5）    // list1 （1,2,3, 0,0 ） 用默认值填补
    
    list1.resize（5,4）    // list1 （1,2,3, 4,4 ） 用指定值 填补
    
    22.reverse（） 反转链表：
    
    list1.reverse（ ）；     // list1（3,2,1）
    
    23.sort（） 对链表排序，默认升序（ 可自定义回调函数 ）
    
    list 对象L1（4,3,5,1,4）
    
    L1.sort（ ）；             &n

bsp;   // L1（1,3,4,4,5）
    
    L1.sort（ greater <int >（） ）； // L1（5,4,4,3,1）
    
    rge（） 合并两个有序链表并使之有序
    
    // 升序
    
    rge（list2）；          // list1（1,2,3,4,5,6） list2 现为空
    
    // 降序
    
    L1（ 3,2,1）， L2（6,5,4）
    
    rge（L2, greater <int >（） ）； // list1（6,5,4,3,2,1） list2 现为空
    
    25.splice（） 对两个链表进行结合（ 三个重载函数） 结合后第二个链表清空
    
    list1.splice（ ++list1.begin（），list2）；
    
    // list1（1,4,5,6,2,3） list2 为空
    
    list1.splice（ ++list1.begin（），list2,list2.begin（））；
    
    // list1（ 1,4,2,3）； list2（5,6）
    
    list1.splice（ ++list1.begin（），list2,++list2.begin（），list2.end（））；
    
    //list1（ 1, 5,6, 2,3）； list2（4）
    
    26.insert（） 在指定位置插入一个或多个元素（ 三个重载函数）
    
    list1.insert（ ++list1.begin（），9）；  // list1（1,9,2,3）
    
    list1.insert（list1.begin（），2,9）；  // list1（9,9,1,2,3）；
    
    list1.insert（list1.begin（），list2.begin（），--list2.end（））；//list1（4,5,1,2,3）；
    
    27.swap（） 交换两个链表（ 两个重载）
    
    list1.swap（list2）；   // list1 （4 ,5 ,6 ） list2 （1 ,2 ,3 ）
    
    28.   unique（） 删除相邻重复元素
    
    L1（ 1, 1 ,4,3,5,1）
    
    L1.unique（ ）；         // L1（1,4,3,5,1）
    
    bool same_integral_part （double first , double second ）
    
    { return （ int （first ）==int （second ） ）； }
    
    L1.unique（ same_integral_part ）；
    
    例子：
    
    // -------------------------------------------------------------------------
    
    // 文件名 : list1.cpp
    
    // 创建者 : 方煜宽
    
    //  邮箱 : 
    
    // 创建时间 : 2010-9-19 15:58
    
    // 功能描述 : STL中的list就是一双向链表，可高效地进行插入删除元素。
    
    //
    
    // -------------------------------------------------------------------------
    
    #include " stdafx.h "
    
    #include < iostream >
    
    #include < list >
    
    using namespace std;
    
    list < int > g_list1;
    
    list < int > g_list2;
    
    //////////////////////////////////////////////////////////////////////// //
    
    // 初始化全局链表
    
    void InitList（）
    
    {
    
    // push_back（）增加一元素到链表尾
    
    g_list1.push_back（ 1 ）；
    
    g_list1.push_back（ 2 ）；
    
    g_list1.push_back（ 3 ）；
    
    // push_front（）增加一元素到链表头
    
    g_list2.push_front（ 6 ）；
    
    g_list2.push_front（ 5 ）；
    
    g_list2.push_front（ 4 ）；
    
    }
    
    // 输出一个链表
    
    void ShowList（list < int >& listTemp）
    
    {
    
    // size（）返回链表中元素个数
    
    cout 《 listTemp.size（） 《 endl;
    
    for （list < int > ::iterator it = listTemp.begin（）； it != listTemp.end（）； ++ it）
    
    {
    
    cout 《 * it 《 ' ' ;
    
    }
    
    cout 《 endl;
    
    }
    
    //////////////////////////////////////////////////////////////////////// //
    
    // 构造函数，空链表
    
    void constructor_test0（）
    
    {
    
    list < int > listTemp;
    
    cout 《 listTemp.size（） 《 endl;
    
    }
    
    // 构造函数，建一个含三个默认值是0的元素的链表
    
    void constructor_test1（）
    
    {
    
    list < int > listTemp（ 3 ）；
    
    ShowList（listTemp）；
    
    }
    
    // 构造函数，建一个含五个元素的链表，值都是1
    
    void constructor_test2（）
    
    {
    
    list < int > listTemp（ 5 , 1 ）；
    
    ShowList（listTemp）；
    
    }
    
    // 构造函数，建一个g_list1的copy链表
    
    void constructor_test3（）
    
    {
    
    list < int > listTemp（g_list1）；
    
    ShowList（listTemp）；
    
    }
    
    // 构造函数，listTemp含g_list1一个区域的元素[_First, _Last）
    
    void constructor_test4（）
    
    {
    
    list < int > listTemp（g_list1.begin（）， g_list1.end（））；
    
    ShowList（listTemp）；
    
    }
    
    // assign（）分配值，有两个重载
    
    // template <class InputIterator>
    
    // void assign （ InputIterator first, InputIterator last ）；
    
    // void assign （ size_type n, const T& u ）；
    
    void assign_test（）
    
    {
    
    list < int > listTemp（ 5 , 1 ）；
    
    ShowList（listTemp）；
    
    listTemp.assign（ 4 , 3 ）；
    
    ShowList（listTemp）；
    
    listTemp.assign（ ++ g_list1.begin（）， g_list1.end（））；
    
    ShowList（listTemp）；
    
    }
    
    // operator=
    
    void operator_equality_test（）
    
    {
    
    g_list1 = g_list2;
    
    ShowList（g_list1）；
    
    ShowList（g_list2）；
    
    }
    
    // front（）返回第一个元素的引用
    
    void front_test7（）
    
    {
    
    cout 《 g_list1.front（） 《 endl;
    
    }
    
    // back（）返回最后一元素的引用
    
    void back_test（）
    
    {
    
    cout 《 g_list1.back（） 《 endl;
    
    }
    
    // begin（）返回第一个元素的指针（iterator）
    
    void begin_test（）
    
    {
    
    list < int > ::iterator it1 = g_list1.begin（）；
    
    cout 《 *++ it1 《 endl;
    
    list < int > ::const_iterator it2 = g_list1.begin（）；
    
    it2 ++ ;
    
    // （*it2）++; // *it2 为const 不用修改
    
    cout 《 * it2 《 endl;
    
    }
   

; 
    // end（）返回 [最后一个元素的下一位置的指针] （list为空时end（）= begin（））
    
    void end_test（）
    
    {
    
    list < int > ::iterator it = g_list1.end（）； // 注意是：最后一个元素的下一位置的指针
    
    -- it;
    
    cout 《 * it 《 endl;
    
    }
    
    // rbegin（）返回链表最后一元素的后向指针
    
    void rbegin_test（）
    
    {
    
    list < int > ::reverse_iterator it = g_list1.rbegin（）；
    
    for （； it != g_list1.rend（）； ++ it）
    
    {
    
    cout 《 * it 《 ' ' ;
    
    }
    
    cout 《 endl;
    
    }
    
    // rend（）返回链表第一元素的下一位置的后向指针
    
    void rend_test（）
    
    {
    
    list < int > ::reverse_iterator it = g_list1.rend（）；
    
    -- it;
    
    cout 《 * it 《 endl;
    
    }
    
    // push_back（）增加一元素到链表尾
    
    void push_back_test（）
    
    {
    
    ShowList（g_list1）；
    
    g_list1.push_back（ 4 ）；
    
    ShowList（g_list1）；
    
    }
    
    // push_front（）增加一元素到链表头
    
    void push_front_test（）
    
    {
    
    ShowList（g_list1）；
    
    g_list1.push_front（ 4 ）；
    
    ShowList（g_list1）；
    
    }
    
    // pop_back（）删除链表尾的一个元素
    
    void pop_back_test（）
    
    {
    
    ShowList（g_list1）；
    
    cout 《 endl;
    
    g_list1.pop_back（）；
    
    ShowList（g_list1）；
    
    }
    
    // pop_front（）删除链表头的一元素
    
    void pop_front_test（）
    
    {
    
    ShowList（g_list1）；
    
    cout 《 endl;
    
    g_list1.pop_front（）；
    
    ShowList（g_list1）；
    
    }
    
    // clear（）删除所有元素
    
    void clear_test（）
    
    {
    
    ShowList（g_list1）；
    
    g_list1.clear（）；
    
    ShowList（g_list1）；
    
    }
    
    // erase（）删除一个元素或一个区域的元素（两个重载函数）
    
    void erase_test（）
    
    {
    
    ShowList（g_list1）；
    
    g_list1.erase（g_list1.begin（））；
    
    ShowList（g_list1）；
    
    cout 《 endl;
    
    ShowList（g_list2）；
    
    g_list2.erase（ ++ g_list2.begin（）， g_list2.end（））；
    
    ShowList（g_list2）；
    
    }
    
    // remove（）删除链表中匹配值的元素（匹配元素全部删除）
    
    void remove_test（）
    
    {
    
    ShowList（g_list1）；
    
    g_list1.push_back（ 1 ）；
    
    ShowList（g_list1）；
    
    g_list1.remove（ 1 ）；
    
    ShowList（g_list1）；
    
    }
    
    bool myFun（ const int & value） { return （value < 2 ）； }
    
    // remove_if（）删除条件满足的元素（会遍历一次链表）
    
    void remove_if_test（）
    
    {
    
    ShowList（g_list1）；
    
    g_list1.remove_if（myFun）；
    
    ShowList（g_list1）；
    
    }
    
    // empty（）判断是否链表为空
    
    void empty_test（）
    
    {
    
    list < int > listTemp;
    
    if （listTemp.empty（））
    
    cout 《 " listTemp为空 " 《 endl;
    
    else
    
    cout 《 " listTemp不为空 " 《 endl;
    
    }
    
    // max_size（）返回链表最大可能长度：1073741823
    
    void max_size_test（）
    
    {
    
    list < int > ::size_type nMax = g_list1.max_size（）；
    
    cout 《 nMax 《 endl;
    
    }
    
    // resize（）重新定义链表长度（两重载函数）：
    
    void resize_test（）
    
    {
    
    ShowList（g_list1）；
    
    g_list1.resize（ 9 ）； // 用默认值填补
    
    ShowList（g_list1）；
    
    cout 《 endl;
    
    ShowList（g_list2）；
    
    g_list2.resize（ 9 , 51 ）； // 用指定值填补
    
    ShowList（g_list2）；
    
    }
    
    // reverse（）反转链表
    
    void reverse_test（）
    
    {
    
    ShowList（g_list1）；
    
    g_list1.reverse（）；
    
    ShowList（g_list1）；
    
    }
    
    // sort（）对链表排序，默认升序（两个重载函数）
    
    void sort_test（）
    
    {
    
    list < int > listTemp;
    
    listTemp.push_back（ 9 ）；
    
    listTemp.push_back（ 3 ）；
    
    listTemp.push_back（ 5 ）；
    
    listTemp.push_back（ 1 ）；
    
    listTemp.push_back（ 4 ）；
    
    listTemp.push_back（ 3 ）；
    
    ShowList（listTemp）；
    
    listTemp.sort（）；
    
    ShowList（listTemp）；
    
    listTemp.sort（greater < int > （））；
    
    ShowList（listTemp）；
    
    }
    
    // merge（）合并两个升序序链表并使之成为另一个升序。
    
    void merge_test1（）
    
    {
    
    list < int > listTemp2;
    
    listTemp2.push_back（ 3 ）；
    
    listTemp2.push_back（ 4 ）；
    
    list < int > listTemp3;
    
    listTemp3.push_back（ 9 ）；
    
    listTemp3.push_back（ 10 ）；
    
    ShowList（listTemp2）；
    
    cout 《 endl;
    
    ShowList（listTemp3）；
    
    cout 《 endl;
    
    rge（listTemp3）；
    
    ShowList（listTemp2）；
    
    }
    
    bool myCmp （ int first, int second）
    
    { return （ int （first） > int （second） ）； }
 &nb

sp;  
    // merge（）合并两个降序链表并使之成为另一个降序。
    
    void merge_test2（）
    
    {
    
    list < int > listTemp2;
    
    listTemp2.push_back（ 4 ）；
    
    listTemp2.push_back（ 3 ）；
    
    list < int > listTemp3;
    
    listTemp3.push_back（ 10 ）；
    
    listTemp3.push_back（ 9 ）；
    
    ShowList（listTemp2）；
    
    cout 《 endl;
    
    ShowList（listTemp3）；
    
    cout 《 endl;
    
    // rge（listTemp3, greater<int>（））； // 第二个参数可以是自己定义的函数如下
    
    rge（listTemp3, myCmp）；
    
    ShowList（listTemp2）；
    
    }
    
    // splice（）对两个链表进行结合（三个重载函数），结合后第二个链表清空
    
    // void splice （ iterator position, list<T,Allocator>& x ）；
    
    // void splice （ iterator position, list<T,Allocator>& x, iterator i ）；
    
    // void splice （ iterator position, list<T,Allocator>& x, iterator first, iterator last ）；
    
    void splice_test（）
    
    {
    
    list < int > listTemp1（g_list1）；
    
    list < int > listTemp2（g_list2）；
    
    ShowList（listTemp1）；
    
    ShowList（listTemp2）；
    
    cout 《 endl;
    
    //
    
    listTemp1.splice（ ++ listTemp1.begin（）， listTemp2）；
    
    ShowList（listTemp1）；
    
    ShowList（listTemp2）；
    
    //
    
    listTemp1.assign（g_list1.begin（）， g_list1.end（））；
    
    listTemp2.assign（g_list2.begin（）， g_list2.end（））；
    
    listTemp1.splice（ ++ listTemp1.begin（）， listTemp2, ++ listTemp2.begin（））；
    
    ShowList（listTemp1）；
    
    ShowList（listTemp2）；
    
    //
    
    listTemp1.assign（g_list1.begin（）， g_list1.end（））；
    
    listTemp2.assign（g_list2.begin（）， g_list2.end（））；
    
    listTemp1.splice（ ++ listTemp1.begin（）， listTemp2, ++ listTemp2.begin（）， listTemp2.end（））；
    
    ShowList（listTemp1）；
    
    ShowList（listTemp2）；
    
    }
    
    // insert（）在指定位置插入一个或多个元素（三个重载函数）
    
    // iterator insert （ iterator position, const T& x ）；
    
    // void insert （ iterator position, size_type n, const T& x ）；
    
    // template <class InputIterator>
    
    // void insert （ iterator position, InputIterator first, InputIterator last ）；
    
    void insert_test（）
    
    {
    
    list < int > listTemp1（g_list1）；
    
    ShowList（listTemp1）；
    
    listTemp1.insert（listTemp1.begin（）， 51 ）；
    
    ShowList（listTemp1）；
    
    cout 《 endl;
    
    list < int > listTemp2（g_list1）；
    
    ShowList（listTemp2）；
    
    listTemp2.insert（listTemp2.begin（）， 9 , 51 ）；
    
    ShowList（listTemp2）；
    
    cout 《 endl;
    
    list < int > listTemp3（g_list1）；
    
    ShowList（listTemp3）；
    
    listTemp3.insert（listTemp3.begin（）， g_list2.begin（）， g_list2.end（））；
    
    ShowList（listTemp3）；
    
    }
    
    // swap（）交换两个链表（两个重载）
    
    void swap_test（）
    
    {
    
    ShowList（g_list1）；
    
    ShowList（g_list2）；
    
    cout 《 endl;
    
    g_list1.swap（g_list2）；
    
    ShowList（g_list1）；
    
    ShowList（g_list2）；
    
    }
    
    bool same_integral_part （ double first, double second）
    
    { return （ int （first） == int （second） ）； }
    
    // unique（）删除相邻重复元素
    
    void unique_test（）
    
    {
    
    list < int > listTemp;
    
    listTemp.push_back（ 1 ）；
    
    listTemp.push_back（ 1 ）；
    
    listTemp.push_back（ 4 ）；
    
    listTemp.push_back（ 3 ）；
    
    listTemp.push_back（ 5 ）；
    
    listTemp.push_back（ 1 ）；
    
    list < int > listTemp2（listTemp）；
    
    ShowList（listTemp）；
    
    listTemp.unique（）； // 不会删除不相邻的相同元素
    
    ShowList（listTemp）；
    
    cout 《 endl;
    
    listTemp.sort（）；
    
    ShowList（listTemp）；
    
    listTemp.unique（）；
    
    ShowList（listTemp）；
    
    cout 《 endl;
    
    listTemp2.sort（）；
    
    ShowList（listTemp2）；
    
    listTemp2.unique（same_integral_part）；
    
    ShowList（listTemp2）；
    
    }
    
    // 主函数，下面要测试哪个就把那个注释去掉即可
    
    int _tmain（ int argc, _TCHAR * argv[]）
    
    {
    
    InitList（）；
    
    // ShowList（g_list1）；
    
    // ShowList（g_list2）；
    
    // constructor_test0（）；
    
    // constructor_test1（）；
    
    // constructor_test2（）；
    
    // constructor_test3（）；
    
    // constructor_test4（）；
    
    // assign_test（）；
    
    // operator_equality_test（）；
    
    // front_test7（）；
    
    // back_test（）；
    
    // begin_test（）；
    
    // end_test（）；
    
    // rbegin_test（）；
    
    // rend_test（）；
    
    // push_back_test（）；
    
    // push_front_test（）；
    
    // pop_back_test（）；
    
    // pop_front_test（）；
    
    // clear_test（）；
    
    // erase_test（）；
    
    // remove_test（）；
    
    // remove_if_test（）；
    
    // empty_test（）；
    
    // max_size_test（）；
    
    // resize_test（）；
    
    // reverse_test（）；
    
    // sort_test（）；
    
    // merge_test1（）；
    
    // merge_test2（）；
    
    // splice_test（）；
    
    //

insert_test（）；
    
    // swap_test（）；
    
    // unique_test（）；
    
    return 0 ;

http://www.educity.cn/develop/476024.html