STL源码剖析－序列式容器之list和slist

一．list

1．list概述

list是双向链表，对于任何位置的元素的插入或元素移除，list永远是常数时间．

２．list的节点

list本身和list节点是不同的数据结构，需要分开设计．STL list的节点结构：

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

３．list的迭代器

STL list 是一格双向链表，迭代器必须具备前移，后移的能力，list提供的是Bidirectional Iterators．list的插入和删除操作都不会导致原来的list迭代器失效．

４．list的数据结构

STL list是一个环状双向链表，只需一个指针就可以表示整个链表．

template<class T,class Alloc = 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迭代器．

５．insert()函数

insert()是一个重载函数，最简单的一种如下：

    iterator insert(iterator position, const T& x){//在迭代器position所指位置插入一个节点，内容为x  
        link_type tmp = create_node(x);  
        tmp->next = position.node;  
        tmp->prev = position.node->prev;  
        (link_type(position.node->prev))->next = tmp;  
        return tmp;  
    }  

６．push_back()函数

将新元素插入list尾端，内部调用insert()函数

void push_back(const T& x){  
insert(end(),x);  
} 

７．push_front()函数

将新元素插入到list头端，内部调用insert()函数

    void push_front(const T&x){  
    insert(begin(),x);  
    }  

８．erase()函数

    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);  
    }

９．pop_front()函数

    void pop_front(){  
    erase(begin());  
    }  

１０．pop_back()函数

移除尾节点，内部调用erase()函数

void pop_back(){  
iterator i=end();  
erase(--i);  
}

１１．transfer()函数

将某连续范围的元素迁移到某个特定位置之前

void transfer(iterator position, iterator first, iterator last) {  
    if (position != last) {  
      (*(link_type((*last.node).prev))).next = position.node; //(1)  
      (*(link_type((*first.node).prev))).next = last.node;    //(2)  
      (*(link_type((*position.node).prev))).next = first.node;//(3)  
      link_type tmp = link_type((*position.node).prev);       //(4)  
      (*position.node).prev = (*last.node).prev;              //(5)  
      (*last.node).prev = (*first.node).prev;                 //(6)  
      (*first.node).prev = tmp;                               //(7)  
    }  
  }

二．slist

１．slist概述

SGI STL另提供一个单向链表slist．slist和list的主要差别在于，前者的迭代器属于单向的Forward Iterator，后者的迭代器属于双向的Bidirectional iterator

根据STL的习惯，插入操作会将新元素插入于指定位置之前．作为单向链表，slist没有任何方便的方法可以回头定出前一个位置，因此它必须从头找起．

２．slist的节点

３．slist的迭代器

４．slist的数据结构

    template<class T, class Alloc = alloc>  
    class slist  
    {  
    public :  
        typedef T   value_type ;  
        typedef value_type* pointer ;   
        typedef const   value_type* const_pointer ;  
        typedef value_type& reference ;  
        typedef const value_type& const_reference ;  
        typedef size_t  size_type ;  
        typedef ptrdiff_t   difference_type ;  


        typedef __slist_iterator<T,T&,T*> iterator ;  
        typedef __slist_iterator<T,const T&,const T*> const_iterator ;  

    private :  
        typedef __slist_node<T>   list_node ;  
        typedef __slist_node_base   list_node_base ;  
        typedef __slist_iterator_base   iterator_base ;  
        typedef simple_alloc<list_node,Alloc> list_node_allocator ;  

        static  list_node* create_node(const value_type& x)  
        {  
            list_node* node = list_node_allocator:;allocate() ; //配置空间  
            __STL_TRY{  
                construct(&node->data,x) ;  
                node->next = 0 ;  
            }  
            __STL_UNWIND(list_node_allocator:;deallocate(node)) ;  
            return node ;  
        }  

        static void destroy_node(list_node* node)  
        {  
            destroy(&node->data) ; //将元素析构     
            list_node_allocator::deallocate(node) ; //释放空间  
        }  

    private :  
        list_node_base head  ; //头部。注意，它不是指针，是实物  


    public:  
        slist() {head.next = 0 ;}   
        ~slist(){clear() ;}  

    public :  
        iterator begin() {return iterator((list_node*)head.next) ;}  
        iterator end() {return iteator(0) ;}  
        iterator size() {const __slist_size(head.next) ;}  
        bool empty() const {return head.next == 0 ;}   

        //两个slist互换：只要将head交换互指即可  
        void swap(slist &L)  
        {  
            list_node_base* tmp = head.next;  
            head.next = L.head.next ;  
            L.head.next = tmp ;  
        }  

    public :  
        //取头部元素  
        reference front() {return ((list_node*)head.next)->data ;}  

        //从头部插入元素(新元素成为slist的第一个元素)  
        void push_front(const value_type& x)  
        {  
            __slist_make_link(&head,create_node(x)) ;  
        }  

        //注意,没有push_back()  

        //从头部取走元素(删除之)。修改head  
        void pop_front()  
        {  
            list_node* node = (list_node*)head.next ;  
            head.next = node->next ;  
            destroy_node(node);  
        }  
        .....  
    }  ;  

５．slist的元素操作