STL—list

前面咱們分析了vector，這篇介紹STL中另外一個重要的容器list

list的設計

list由三部分構成：list節點、list迭代器、list自己

list節點

list是一個雙向鏈表，因此其list節點中有先後兩個指針。以下：

// list節點
template <typename T>
struct __list_node
{
        typedef void* void_pointer;
        void_pointer prev; // 指向前一個節點
        void_pointer next; // 指向下一個節點
        T data; // 節點的值
};

list迭代器

前面咱們說過vector是利用其內存分配類型成員給vector分配一大塊內存，而其迭代器是原始指針，因此其迭代器的移動就是指針的移動，vector那樣經過指針的移動就能獲得下一個元素，不須要特別設計。而list是鏈表結構，鏈表中每一個節點的內存不連續，list的迭代器就是對外隱藏了從一個節點是如何移動到下一個節點的具體細節，使得外部只要將迭代器自增或自減就能獲得相鄰的節點。

list迭代器只有一個指向鏈表節點的指針數據成員。以下：

        typedef __list_node<T>* link_type;

        link_type node;  // point to __list_node

下面是迭代器的前置自增和前置自減運算符的源碼，能夠看到是經過節點的前向和後向指針來完成從一個節點移動到另外一個節點：

        self& operator++() { node = (link_type)(*node).next; return *this;}
        self& operator--() { node = (link_type)(*node).prev; return *this;}

list

和vector同樣，list也有個空間配置器的類型成員，經過該類型來爲list的每一個節點分配內存，而且經過該類型成員將外部指定的節點數目轉換爲相應節點所需的內存。因此list的內存模型是每一個鏈表節點分配一塊單獨的內存，而後將每一個節點鏈接起來。而vector的內存模型是分配一大塊連續的內存。以下：

          // 空間配置器
          typedef simple_alloc<list_node, alloc> list_node_allocator;

 

實際上，list不只是一個雙向鏈表，並且仍是一個環狀的雙向鏈表。爲了設計的方便，在list中放置一個node指針，該指針指向一個空白節點，該空白節點的下一個節點是鏈表中起始節點，而鏈表的尾節點的下一個節點爲該空白節點。雖然list底層是一個環狀雙向鏈表，但經過這樣設計後對外就表現出一個普通的雙向鏈表，符合通常習慣。這樣設計還有不少好處，好比快速獲得鏈表的首尾節點。以下。

private:
        //指向空白節點
        link_type               node;
public:
        // 經過空白節點node完成
        iterator begin() const { return (link_type)(*node).next; }
        iterator end() const { return node;}
        bool empty() const { return node->next == node; }

 

下面咱們看list內部是如何構造一個鏈表的。以咱們對list的經常使用使用方法 list<int> lis(10)爲例：

首先調用構造函數

        explicit list(size_type n)
        {
                empty_initialize();
                insert(begin(), n, T());
        }

該構造函數會先調用empty_initialize()爲list分配一個空白節點，並設置前向後向指針

        void empty_initialize()
        {
                node = get_node();
                node->next = node;
                node->prev = node;
        }
        link_type get_node() { return list_node_allocator::allocate(1);}

而後構造函數會循環以插入相應個數的鏈表節點，每次插入時會分配一個節點大小的內存，而後對這塊內存初始化，注意插入位置是在指定位置以前插入。因爲list的內存模型和vector內存模型的區別，vector每次插入時因爲可能會形成內存的從新配置，會形成原先全部的迭代器失效。而list的插入只是爲新節點分配內存，並將其添加到鏈表中，對鏈表中其餘節點的內存不會形成影響，因此list的插入則不會引發迭代器失效。以下。

template <typename T>
void
list<T>::insert(iterator position, size_type n, const T& x)
{
        for (; n > 0; --n)
                insert(position, x);
}

template <typename T>
void
list<T>::insert(iterator position, const T& x)//posiiton以前插入
{
        link_type tmp = create_node(x);
        tmp->next = position.node;
        tmp->prev = position.node->prev;
        (link_type(position.node->prev))->next = tmp;
        position.node->prev = tmp;
}

link_type create_node(const T& x)
{
        link_type p = get_node();
        construct(&p->data, x);
        return p;
}

link_type get_node() { return list_node_allocator::allocate(1);}

 

（全文完）

附：

STL系列文章： http://www.cnblogs.com/zxiner/p/7197402.html

一款簡易版STL的實現，項目地址： https://github.com/zinx2016/MiniSTL/tree/master/MiniSTL