STL源碼分析之List

list是個環形雙向鏈表，裏面的迭代器類型是bidirectional_iterator_tag，可以雙向移動，不想vector裏可以隨機訪問。同時刪除或添加結點對其他的迭代器無影響。List也有sort函數，我們知道sort函數只支持隨機訪問型迭代器，所有它的sort是自己另外聲明的。下面是源碼分析，基本都標註了各函數功能和分析

template <class T>
struct __list_node  //鏈表節點
{
    typedef void* void_pointer;
    void_pointer next;
    void_pointer prev;
    T data;
};


template<class T, class Ref, class Ptr> //使結點能進行->,*等操作
struct __list_iterator
{
    //迭代器，用到了偏特化，當模板參數是T, T&, T* 對應iterator
    typedef __list_iterator<T, T&, T*>             iterator;
    typedef __list_iterator<T, const T&, const T*> const_iterator;
    typedef __list_iterator<T, Ref, Ptr>           self;

    //list的迭代器類型是bidirectional_iterator_tag
    typedef bidirectional_iterator_tag iterator_category;
    typedef T value_type;
    typedef Ptr pointer;
    typedef Ref reference;
    typedef __list_node<T>* link_type;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    //指向結點的指針
    link_type node;

    //迭代器構造函數
    __list_iterator(link_type x) : node(x) {}
    __list_iterator() {}
    __list_iterator(const iterator& x) : node(x.node) {}

    //運算符重載
    bool operator==(const self& x) const { return node == x.node; }
    bool operator!=(const self& x) const { return node != x.node; }

    // 對迭代器取值,取的是節點的數據值
    reference operator*() const { return (*node).data; }
    // 指向迭代器就是指向其數據
    pointer operator->() const { return &(operator*()); }
    // 迭代器後移
    self& operator++()
    {
        node = (link_type)((*node).next);
        return *this;
    }
    self operator++(int)
    {
        self tmp = *this;
        ++*this;
        return tmp;
    }
    // 前移
    self& operator--()
    {
        node = (link_type)((*node).prev);
        return *this;
    }
    self operator--(int)
    {
        self tmp = *this;
        --*this;
        return tmp;
    }
};

template <class T, class Alloc = alloc>
class list
{
protected:
    typedef void* void_pointer;
    typedef __list_node<T> list_node;
    //list空間配置函數
    typedef simple_alloc<list_node, Alloc> list_node_allocator;

public:
    typedef T value_type;
    typedef value_type* pointer;
    typedef value_type& reference;
    typedef list_node* link_type;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;

    typedef __list_iterator<T, T&, T*> iterator;

protected:
    link_type node ;
    //調用空間配置器分配一個結點
    link_type get_node() { return list_node_allocator::allocate(); }
    //釋放一個結點
    void put_node(link_type p) { list_node_allocator::deallocate(p); }
    //構造結點
    link_type create_node(const T& x)
    {
        link_type p = get_node();
        construct(&p->data, x);
        return p;
    }

    // 析構結點元素, 並釋放內存
    void destroy_node(link_type p)
    {
        destroy(&p->data);
        put_node(p);
    }

protected:
    // 初始化時申請了一個空結點
    void empty_initialize()
    {
        node = get_node();
        node->next = node;
        node->prev = node;
    }

    // 創建值爲value共n個結點的鏈表
    void fill_initialize(size_type n, const T& value)
    {
        empty_initialize();
        __STL_TRY
        {
            //在頭結點後插入n個值爲value的結點
            insert(begin(), n, value);
        }
        __STL_UNWIND(clear(); put_node(node));
    }


public:
    list() { empty_initialize(); }
    //從頭結點的下一個開始
    iterator begin() { return (link_type)((*node).next); }

    //返回頭結點（環形鏈表）
    iterator end() { return node; }

    // 頭結點指向自身說明鏈表中無元素
    bool empty() const { return node->next == node; }

    // 使用distance()進行計算, 時間複雜度O(n)
    size_type size() const
    {
        size_type result = 0;
        distance(begin(), end(), result);   //對於b型迭代器計算距離只能一步步，開銷較大
        return result;
    }
    size_type max_size() const { return size_type(-1); }
    reference front() { return *begin(); }
    reference back() { return *(--end()); }

    iterator insert(iterator position, const T& x)
    {
        //創建個結點
        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;
        return tmp;
    }
    //連續插入幾個結點
    void insert(iterator pos, size_type n, const T& x);

    void insert(iterator pos, int n, const T& x)
    {
        insert(pos, (size_type)n, x);
    }
    void insert(iterator pos, long n, const T& x)
    {
        insert(pos, (size_type)n, x);
    }

    // 在鏈表前端插入結點
    void push_front(const T& x) { insert(begin(), x); }
    // 在鏈表最後插入結點
    void push_back(const T& x) { insert(end(), x); }

    // 移除迭代器position所指節點,注意移除後其他結點迭代器任有效
    iterator erase(iterator position)
    {
        link_type next_node = link_type(position.node->next);
        link_type prev_node = link_type(position.node->prev);
        prev_node->next = next_node;
        next_node->prev = prev_node;
        destroy_node(position.node);
        return iterator(next_node);
    }

    iterator erase(iterator first, iterator last);

    void resize(size_type new_size, const T& x);
    void resize(size_type new_size) { resize(new_size, T()); }
    void clear();

    // 刪除鏈表第一個結點
    void pop_front() { erase(begin()); }
    // 刪除鏈表最後一個結點
    void pop_back()
    {
        iterator tmp = end();
        erase(--tmp);
    }

    list(size_type n, const T& value) { fill_initialize(n, value); }
    list(int n, const T& value) { fill_initialize(n, value); }
    list(long n, const T& value) { fill_initialize(n, value); }

    ~list()
    {
        // 釋放所有結點  // 使用全局函數distance()進行計算, 時間複雜度O(n)
        size_type size() const
        {
            size_type result = 0;
            distance(begin(), end(), result);
            return result;
        }
        clear();
        // 釋放頭結點
        put_node(node);
    }

    list<T, Alloc>& operator=(const list<T, Alloc>& x);

protected:

    //將[first, last)範圍內的元素移動到position前
    void transfer(iterator position, iterator first, iterator last)
    {
        if (position != last)
        {
            //有點繞，畫畫圖就清晰了
            (*(link_type((*last.node).prev))).next = position.node;
            (*(link_type((*first.node).prev))).next = last.node;
            (*(link_type((*position.node).prev))).next = first.node;
            link_type tmp = link_type((*position.node).prev);
            (*position.node).prev = (*last.node).prev;
            (*last.node).prev = (*first.node).prev;
            (*first.node).prev = tmp;
        }
    }

public:
    // 將鏈表x移動到position所指位置之前
    void splice(iterator position, list& x)
    {
        if (!x.empty())
            transfer(position, x.begin(), x.end());
    }

    // 將鏈表中i指向的內容移動到position之前
    void splice(iterator position, list&, iterator i)
    {
        iterator j = i;
        ++j;
        if (position == i || position == j) return;
        transfer(position, i, j);
    }

    // 將鏈表[first, last}元素移動到position之前
    void splice(iterator position, list&, iterator first, iterator last)
    {
        if (first != last)
            transfer(position, first, last);
    }

    void remove(const T& value);
    void unique();
    void merge(list& x);
    void reverse();
    void sort();

};

// 銷燬所有結點, 將鏈表置空
template <class T, class Alloc>
void list<T, Alloc>::clear()
{
    link_type cur = (link_type) node->next;
    while (cur != node)
    {
        link_type tmp = cur;
        cur = (link_type) cur->next;
        destroy_node(tmp);
    }
    node->next = node;
    node->prev = node;
}

//鏈表直接賦值
template <class T, class Alloc>
list<T, Alloc>& list<T, Alloc>::operator=(const list<T, Alloc>& x)
{
    if (this != &x)
    {
        iterator first1 = begin();
        iterator last1 = end();
        const_iterator first2 = x.begin();
        const_iterator last2 = x.end();
        while (first1 != last1 && first2 != last2) *first1++ = *first2++;
        if (first2 == last2)
            erase(first1, last1);   //將原先多餘的點去掉
        else
            insert(last1, first2, last2);
    }
    return *this;
}


//將相鄰的重複的點去掉
template <class T, class Alloc>
void list<T, Alloc>::unique()
{
    iterator first = begin();
    iterator last = end();
    if (first == last) return;
    iterator next = first;
    while (++next != last)
    {
        if (*first == *next)
            erase(next);
        else
            first = next;
        next = first;
    }
}


template <class T, class Alloc>
void list<T, Alloc>::merge(list<T, Alloc>& x)
{
    iterator first1 = begin();
    iterator last1 = end();
    iterator first2 = x.begin();
    iterator last2 = x.end();


    while (first1 != last1 && first2 != last2)
        if (*first2 < *first1)
        {
            iterator next = first2;
            transfer(first1, first2, ++next);
            first2 = next;
        }
        else
            ++first1;
    if (first2 != last2)
        transfer(last1, first2, last2);
}

來簡單實踐下它的操作函數

#include <iostream>
#include <list>
#include <vector>

using namespace std;


void Print(list<int> s){
    auto start = s.begin();
    auto end = s.end();
    while(start != end){
        cout<<*start<<" ";
        start++;
    }
    cout<<endl;
}
int main()
{
    list<int> s(5,3);
    Print(s);
    s.insert(s.begin(),4);  //注意不能寫成s.begin()+n
    Print(s);
    vector<int> ss{1,2,3,4};
    s.insert(s.begin(),ss.begin(),ss.end());    //可以在鏈表中加上任意容器元素
    Print(s);
    //s.transfer(s.begin(),ss.begin(),ss.end()); //?不能直接調用？
    list<int> s1(5,7);
    //insert是創建新的結點，splice是直接將原來的結點交接到這個鏈表後面
    s.splice(s.end(),s1);   //將鏈表拼接在迭代器後
    Print(s);
    s.reverse();
    Print(s);
    s.sort();
    Print(s);
    return 0;
}