c++容器

一. 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（ ）；             &nbsp;   // L1（1,3,4,4,5）
   
    L1.sort（ greater <int >（） ）； // L1（5,4,4,3,1）
   
    24.merge（） 合并两个有序链表并使之有序
   
    // 升序
   
    list1.merge（list2）；          // list1（1,2,3,4,5,6） list2 现为空
   
    // 降序
   
    L1（ 3,2,1）， L2（6,5,4）
   
    L1.merge（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
   
    // 创建者 : 方煜宽
   
    //  邮箱 : [email protected]
   
    // 创建时间 : 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;
   
    listTemp2.merge（listTemp3）；
   
    ShowList（listTemp2）；
   
    }
   
    bool myCmp （ int first, int second）
   
    { return （ int （first） > int （second） ）； }
 &nbsp; 
    // 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;
   
    // listTemp2.merge（listTemp3, greater<int>（））； // 第二个参数可以是自己定义的函数如下
   
    listTemp2.merge（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 ;

  (1)以上原文链接,感谢原作者

一个实例:

#include <iostream>
#include <list>
#include <numeric>
#include <algorithm>

using namespace std;

//创建一个list容器的实例LISTINT
typedef list<int> LISTINT;

//创建一个list容器的实例LISTCHAR
typedef list<char> LISTCHAR;

void main(void)
{
    //--------------------------
    //用list容器处理整型数据
    //--------------------------
    //用LISTINT创建一个名为listOne的list对象
    LISTINT listOne;
    //声明i为迭代器
    LISTINT::iterator i;

    //从前面向listOne容器中添加数据
    listOne.push_front (2);
    listOne.push_front (1);

    //从后面向listOne容器中添加数据
    listOne.push_back (3);
    listOne.push_back (4);

    //从前向后显示listOne中的数据
    cout<<"listOne.begin()--- listOne.end():"<<endl;
    for (i = listOne.begin(); i != listOne.end(); ++i)
        cout << *i << " ";
    cout << endl;

    //从后向后显示listOne中的数据
LISTINT::reverse_iterator ir;
    cout<<"listOne.rbegin()---listOne.rend():"<<endl;
    for (ir =listOne.rbegin(); ir!=listOne.rend();ir++) {
        cout << *ir << " ";
    }
    cout << endl;

    //使用STL的accumulate(累加)算法
    int result = accumulate(listOne.begin(), listOne.end(),0);
    cout<<"Sum="<<result<<endl;
    cout<<"------------------"<<endl;

    //--------------------------
    //用list容器处理字符型数据
    //--------------------------

    //用LISTCHAR创建一个名为listOne的list对象
    LISTCHAR listTwo;
    //声明i为迭代器
    LISTCHAR::iterator j;

    //从前面向listTwo容器中添加数据
    listTwo.push_front ('A');
    listTwo.push_front ('B');

    //从后面向listTwo容器中添加数据
    listTwo.push_back ('x');
    listTwo.push_back ('y');

    //从前向后显示listTwo中的数据
    cout<<"listTwo.begin()---listTwo.end():"<<endl;
    for (j = listTwo.begin(); j != listTwo.end(); ++j)
        cout << char(*j) << " ";
    cout << endl;

    //使用STL的max_element算法求listTwo中的最大元素并显示
    j=max_element(listTwo.begin(),listTwo.end());
    cout << "The maximum element in listTwo is: "<<char(*j)<<endl;
}

2. sort中用到自定义的函数排序实例

#include "Student.cpp"

#include <iostream>
#include <list>
#include <numeric>
#include <algorithm>
#include <iostream>
#include <conio.h>

bool cmp(Student& s1, Student& s2)
{
     return (s1.GetID() < s2.GetID());//从小到大排序
}

struct cmp2
{
    bool operator () (Student& s1,Student& s2)
    {
        return (s1.GetID() < s2.GetID());//从小到大排序
    }
};

int main()
{
    typedef list<Student> LISTSTUDENT;

    LISTSTUDENT list;
    LISTSTUDENT::iterator i;//迭代器

    Student *stu = new Student();

    int i_number = 10;
    cout << "请输入要添加处理的学生数量:    ";
    cin >> i_number;

    int i_id = 0, i_age = 20,i_grade = 90;
    char c_sex = 'M';//Man/Female
    string str_name = "**";

    for(int l = 1; l <= i_number; l++)
    {
		cout << "NO . " << l << ": " << endl;
        cout << "学号 :  ";  cin >> i_id ; stu->SetID(i_id);
        cout << "姓名 :  ";  cin >> str_name; stu->SetName(str_name);
        cout << "年龄 :  ";  cin >> i_age; stu->SetAge(i_age);
        cout << "性别 :  ";  cin >> c_sex; stu->SetSex(c_sex);
        cout << "成绩 :  ";  cin >> i_grade; stu->SetGrade(i_grade);

        list.push_back(*stu);//从后面向listOne容器中添加数据
    }

	list.sort(cmp);//或者list.sort(cmp2());

    //从前向后显示list中的数据
    cout<<"所有学生信息:   "<<endl;
    int j = 1;
    for (i = list.begin(); i != list.end(); ++i)
	{
	    cout << "NO . " << j++ << ":  ";
        cout << i->GetID() << "  ";
        cout << i->GetName() << "  ";
        cout << i->GetAge() << "  ";
        cout << i->GetSex() << "  ";
        cout << i->GetGrade() << endl;
	}
    cout << endl;

	system("pause");

    return 0;
}