1.list

　　相較於vector的連續線性空間，list就顯得複雜很多，它的好處是每次插入或刪除一個元素，就配置或釋放一個元素的空間。因此，list對空間的運用有絕對的精確，一點也不浪費。而且，對於任何位置的元素插入和元素移除，list永遠是常數時間。 　　list的節點結構：

template <class T>
struct __list_node
{
    typedef void* void_pointer;
    void_pointer prev;
    void_pointer next;
    T data;
}

　　list的迭代器：
　　list不再能夠像vector一樣以普通指標作為迭代器，因為其節點不保證在儲存空間中連續存在。list迭代器必須有能力指向list的節點，並有能力進行正確的遞增、遞減、取值、成員存取等操作。由於STL list是一個雙向連結串列，迭代器必須具備前移、後移的能力，所以list提供的是Bidirectional Iterators。list有一個重要性質：插入操作和結合操作都不會造成原有的list迭代器失效，甚至list的元素刪除操作也只有“指向被刪除元素”的那個迭代器失效，其他迭代器不受任何影響。
　　list的資料結構：
　　SGI list不僅是一個雙向連結串列，而且還是一個環狀雙向連結串列。所以它只需要一個指標，便可以完整表現整個連結串列：

template <class T,class Alloc = alloc>
class list
{
protected:
    typedef __list_node<T> list_node;
public:
    typedef list_node* link_type;
protected:
    link_type node;
    ...
};
 

　　如果讓指標node指向刻意置於尾端的一個空白節點，node便能符合STL對於“前開後閉”區間的要求，成為last迭代器。

2.函式成員

2.1建構函式：

/// Creates an empty list.
list();
/// Creates a list with n elements, each of which is a copy of T().
list(size_type n);
/// Creates a list with n copies of t.
list(size_type n, const T& t);
/// The copy constructor.
list(const list&);
/// Creates a list with a copy of a range.
template <class InputIterator> list(InputIterator f, InputIterator l);
 

2.2解構函式：

/// The destructor.
~list();

2.3插入元素：

/// Inserts a new element at the beginning.
void push_front(const T&);
/// Inserts a new element at the end.
void push_back(const T&);
/// Inserts x before pos.
iterator insert(iterator pos, const T& x);
/// Inserts the range [f, l) before pos.
template <class InputIterator> void insert(iterator pos, InputIterator f, InputIterator l);
/// Inserts n copies of x before pos.
void insert(iterator pos, size_type n, const T& x);
 

2.4刪除元素：

/// Removes the first element.
void pop_front();
/// Removes the last element.
void pop_back();
/// Erases the element at position pos.
iterator erase(iterator pos);
/// Erases the range [first, last)
iterator erase(iterator first, iterator last);
/// 刪除指定數值元素
void remove(const T& value);
/// 移除數值相同的連續元素
void unique();
/// Erases all of the elements.
void clear();

2.5返回元素指標或元素：

/// Returns an iterator pointing to the beginning of the list.
iterator begin();
/// Returns an iterator pointing to the end of the list.
iterator end();
/// Returns a reverse_iterator pointing to the beginning of the reversed list.
reverse_iterator rbegin();
/// Returns a reverse_iterator pointing to the end of the reversed list.
reverse_iterator rend();
/// Returns the first element.
reference front();
/// Returns the last element.
reference back();

2.6其他：

/// Returns the size of the list.
size_type size() const;
/// Returns the largest possible size of the list.
size_type max_size() const;
/// true if the list's size is 0.
bool empty() const;
/// 容器拼接
void splice(iterator pos, list& L);
void splice(iterator pos, list& L, iterator i);
void splice(iterator pos, list& L, iterator f, iterator l);
/// 元素排序
void sort();
/// 容器合併
void merge(list& L);
/// 容器內容逆向重置
void reverse();

3.例項

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

int main()
{
    typedef std::list<int> ILIST;

    /// 1.例項物件
    ILIST first;                                // empty
    ILIST second(5);                            // 0 0 0 0 0
    ILIST third(5,10);                          // 10 10 10 10 10
    ILIST fourth(third);                        // 10 10 10 10 10
    ILIST fifth(third.begin(),third.end());     // 10 10 10 10 10

    /// 2.插入元素
    ILIST::iterator ilitr;
    ILIST ilist;
    /// 2.1尾部插入元素
    ilist.push_back(1);
    ilist.push_back(2);
    ilist.push_back(3);                         // 1 2 3
    /// 2.2頭部插入元素
    ilist.push_front(8);
    ilist.push_front(16);                       // 16 8 1 2 3
    /// 2.3指定位置插入元素
    ilitr = find(ilist.begin(),ilist.end(),1);
    if(ilitr != ilist.end())
        ilist.insert(ilitr,4);                  // 16 8 4 1 2 3

    /// 3.刪除元素
    /// 3.1刪除尾部元素
    ilist.pop_front();                          // 8 4 1 2 3
    /// 3.2刪除頭部元素
    ilist.pop_back();                           // 8 4 1 2
    /// 3.3刪除指定位置元素
    ilitr = find(ilist.begin(),ilist.end(),1);
    if(ilitr != ilist.end())
        ilist.erase(ilitr);                     // 8 4 2
    /// 3.4刪除指定數值元素
    ilist.remove(8);                            // 4 2
    /// 3.5移除數值相同的連續元素
    ilist.push_back(3);
    ilist.push_back(3);
    ilist.push_back(4);                         // 4 2 3 3 4
    ilist.unique();                             // 4 2 3 4
    /// 3.6清空所有元素
    ilist.clear();                              // empty

    /// 4.訪問元素
    ilist.push_back(1);
    ilist.push_back(2);
    ilist.push_back(4);
    /// 4.1訪問頭部元素
    ilist.front();                              // 1
    /// 4.2訪問尾部元素
    ilist.back();                               // 4

    /// 5.其他
    /// 5.1容器尺寸
    ilist.size();                               // 3
    /// 5.2容器最大尺寸
    ilist.max_size();                           // 768614336404564650
    /// 5.3容器是否為空
    ilist.empty();                              // 0
    /// 5.4容器拼接
    ILIST oilist;
    oilist.push_back(3);
    ilitr = find(ilist.begin(),ilist.end(),4);
    ilist.splice(ilitr,oilist);                 // 1 2 3 4
    /// 5.5容器合併
    oilist.push_back(12);
    oilist.push_back(6);
    oilist.push_back(9);
    oilist.sort();
    /// 兩個lists的內容都必須先經過遞增排序
    ilist.merge(oilist);                        // 1 2 3 4 6 9 12
    /// 5.6容器內容逆向重置
    ilist.reverse();                            // 12 9 6 4 3 2 1

    return 0;
}

4.參考文獻

　　本文內容摘錄於《STL原始碼剖析》