STL之list

前言

list是双向链表容器。当经常从容器的中间插入元素或者删除元素时，非常高效。

#include <list>

list基础

list定义模板
template < class T, class Allocator = allocator< T>>class list
T是存储的元素的数据类型；Allocator指定了分配器，默认是标准分配器。

list构造函数
explicit list(const Allocator &a = Allocator());
构造空的list
explicit list(size_type num,const T &val = T(),const Allocator &a = Allocator());
构造含有num个元素，元素值为val的list
list(const list< T,Allocator> &ob);
list的拷贝构造函数
template < class InIter> list(InIter start,InIter end, const Allocator &a = Allocator());
构造list含有的元素由start和end指定范围内的元素组成

list重载了赋值操作符和比较操作符：
==，<,<=,!=,>,>=

list不支持随机访问操作，不提供at()函数，也不支持[]操作符。

list具体类型

size_type	整数类型
difference_type	能够区分两个地址不同的整数类型
reference	元素的引用(T&)
const_reference	元素的常量引用(const T&)
iterator	迭代器
const_iterator	const迭代器
reverse_iterator	反向迭代器
const_reverse_iterator	const反向迭代器
value_type	存储在容器中值的类型（T）
allocator_type	分配器类型
pointer	指向元素的指针
const_pointer	指向元素的常量指针（const T*）

性能特点
在list中插入和删除操作是个常量时间。
删除操作只会导致指向被删除元素的迭代器和被删除元素的引用失效，不会影响其他仍然存在元素的迭代器和引用

list成员函数

template < class InIter >
template < class Comp>

void assign(InIter start,InIter end)	将start和end之间的序列赋值给list
void assign(size_type num, const T &val)	将num个值为val的元素赋值给list
reference back(); const_reference back() const	返回list中最后一个元素的引用
iterator begin(); const_iterator begin() const	返回list中第一个元素的迭代器
void clear()	删除list中所有元素
bool empty() const	如果调用list是空返回true，否则返回false
iterator end(); const_iterator end() const	返回list指向尾部的迭代器
iterator erase(iterator i)	删除指向i的元素，返回迭代器，迭代器指向元素为被删除元素的下一个元素
iterator erase(iterator start,iterator end)	删除start和end之间的元素。返回迭代器，此迭代器起始位置指向最后一个被删除元素的下一个元素
reference front(); const_reference front() const	返回list中第一个元素的引用
allocator_type get_allocator() const	返回list的分配器
iterator insert(iterator i, const T &val = T())	在元素i之前插入值为val的元素。返回指向该元素的迭代器
void insert(iterator i,size_type num, const T &val)	在元素i之前插入num个值为val的元素
void insert(iterator i, InIter start,InIter end)	在元素i之前插入由start和end定义的的序列
size_type max_size() const	返回list能保存的最大元素个数
void pop_back()	删除list中最后一个元素
void pop_front()	删除list中第一个元素
void push_back(const T &val)	将值为val的元素加入到list尾部
void push_front(cosnt T &val)	将值为val的元素加入到list的头部
reverse_iterator rbegin(); const_reverse_iterator rbegin() const;	返回一个反向迭代器，指向list结束位置
void remove(const T&val)	从list中删除值为val的元素
template void remove_if(UnPred pr)	删除pr判定为true的元素
reverse_iterator rend(); const_reverse_iterator rend() const	返回反向迭代器，指向list起始位置
void resize(size_type num, T val = T())	改变list的大小为num，如果list扩容了，那么新增值为val的元素直到list结束位置
void reverse()	反向调用list
size_type() size() const	返回list中当前元素个数
void sort(); template void sort(Comp cmpfn)	排序list。第二个list排序，使用比较函数cmpfn去判断某个元素比另一个元素小
void unique(); template void unique(BinPred pr)	从调用list中删除重复元素。第二个函数形式是使用pr去判断什么时候两个元素时重复的

void merge( list< T, Allocator> &ob);
void merge( < list< T, Allocator> &ob , Comp cmpfn > ) ;
将有序list ob和调用list进行合并，合并后的结果也排好序。合并完后，ob为空。
第二种形式，将由cmpfn函数来进行比较，判断元素是否小于另一个元素。
注意：第一种形式的merge函数要求调用list和ob都必须是已拍好序的list，这样当调用merge后，结果才会也是排好序的。如果调用list是非排好序的，则调用merge后的结果list也是无序的。

void splice(iterator i,list < T, Allocator> &ob)
将ob的内容插入到调用list的位置i处，插入完成后，ob为空

void splice(iterator i,list < T, Allocator> &ob,iterator el)
从ob中删除由el指向的元素，并将el元素存储到调用list的位置i处

void splice(iterator i,list < T, Allocator> &ob,iterator start,iterator end)从ob中删除由start和end定义的范围序列，并存储到调用list中，存储位置从i位置开始

void swap(list < T,Allocator> &ob)
交换调用list和ob之间的元素

Example

    list<int> l;
    list<int> ob;
    int i = 0;
    list<int>::iterator p;

    for (i=0;i<10;i++)
    {
        l.push_back(i);
    }

    for (i=5;i<15;i++)
    {
        ob.push_back(i);
    }

    cout<<"initial contents of l:\n";
    p = l.begin();
    while (p!=l.end())
    {
        cout<<*p<<" ";
        p++;
    }
    cout<<"\n\n";

    cout<<"initial contents of ob:\n";
    p = ob.begin();
    while (p!=ob.end())
    {
        cout<<*p<<" ";
        p++;
    }
    cout<<"\n\n";

    //merge
    l.merge(ob);

    cout<<"after merge,size of ob: "<<ob.size()<<"\n\n";

    cout<<"after merge,contents of l: \n";
    p = l.begin();
    while (p!=l.end())
    {
        cout<<*p<<" ";
        p++;
    }