STL源码剖析——slist

slist是SGI STL里面的一个单向链表，不过这个不属于标准定义，所以，G++下面不能用，另外看了下VS2008里面也没有。不过看到书上这一部分讲解，还是配合SGI的代码做一个了解。一般情况下使用标准的list就可以满足要求了，而且会更加方便，list的分析可以参考STL源码剖析——list一文。因为slist是单向链表，所以它的迭代器类型为forward_iterator。

1. slist节点设计
链表最基本的结构就是指针域和数据域，对单向链表的节点而言，其拥有一个next指针，指向下一个节点，同时拥有一个数据域用于存储节点的数据。slist在这里做了一个分层处理，基类_Slist_node_base只有next指针，用于链表的构造，子类_Slist_node继承自_Slist_node_base，同时拥有一个存储数据的成员。

// node 基类struct _Slist_node_base{  _Slist_node_base* _M_next;}; // slist_nodetemplate <class _Tp>struct _Slist_node : public _Slist_node_base{  _Tp _M_data;};

一些基本的函数操作，基于_Slist_node_base指针类型。可以看到因为单链表只能往后迭代，所以很多操作都没有提供，即使提供了，也是非常低效的操作，需要从头结点开始遍历。

// 在prev后面插入新节点，返回指向新的节点的指针inline _Slist_node_base*__slist_make_link(_Slist_node_base* __prev_node,                  _Slist_node_base* __new_node){  __new_node->_M_next = __prev_node->_M_next;  __prev_node->_M_next = __new_node;  return __new_node;} // 返回指定节点的上一个节点，需要从head开始遍历inline _Slist_node_base* __slist_previous(_Slist_node_base* __head,                 const _Slist_node_base* __node){  while (__head && __head->_M_next != __node)    __head = __head->_M_next;  return __head;} // 拼接操作：将[before_first->next, before_last]拼接到pos后inline void __slist_splice_after(_Slist_node_base* __pos,                                 _Slist_node_base* __before_first,                                 _Slist_node_base* __before_last){  if (__pos != __before_first && __pos != __before_last) {    _Slist_node_base* __first = __before_first->_M_next;    _Slist_node_base* __after = __pos->_M_next;    __before_first->_M_next = __before_last->_M_next;    __pos->_M_next = __first;    __before_last->_M_next = __after;  }} // 将head指向的链表拼接到pos之后inline void__slist_splice_after(_Slist_node_base* __pos, _Slist_node_base* __head){  _Slist_node_base* __before_last = __slist_previous(__head, 0);  if (__before_last != __head) {    _Slist_node_base* __after = __pos->_M_next;    __pos->_M_next = __head->_M_next;    __head->_M_next = 0;    __before_last->_M_next = __after;  }} // 翻转链表inline _Slist_node_base* __slist_reverse(_Slist_node_base* __node){  _Slist_node_base* __result = __node;  __node = __node->_M_next;  __result->_M_next = 0;  while(__node) {    _Slist_node_base* __next = __node->_M_next;    __node->_M_next = __result;    __result = __node;    __node = __next;  }  return __result;} // 求链表的节点个数inline size_t __slist_size(_Slist_node_base* __node){  size_t __result = 0;  for ( ; __node != 0; __node = __node->_M_next)    ++__result;  return __result;}

2. slist迭代器设计
slist的迭代器属于forward iterator，只能往前迭代，因此除了迭代器的基本操作之外，只实现了operator++操作。

// iterator基类struct _Slist_iterator_base{  typedef size_t               size_type;  typedef ptrdiff_t            difference_type;  // 迭代器类型为forward_iterator  typedef forward_iterator_tag iterator_category;   _Slist_node_base* _M_node;   _Slist_iterator_base(_Slist_node_base* __x) : _M_node(__x) {}   // 只提供往前访问的方法  void _M_incr() { _M_node = _M_node->_M_next; }   bool operator==(const _Slist_iterator_base& __x) const {    return _M_node == __x._M_node;  }   bool operator!=(const _Slist_iterator_base& __x) const {    return _M_node != __x._M_node;  }}; // 迭代器定义template <class _Tp, class _Ref, class _Ptr>struct _Slist_iterator : public _Slist_iterator_base{  typedef _Slist_iterator<_Tp, _Tp&, _Tp*>             iterator;  typedef _Slist_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;  typedef _Slist_iterator<_Tp, _Ref, _Ptr>             _Self;   typedef _Tp              value_type;  typedef _Ptr             pointer;  typedef _Ref             reference;  typedef _Slist_node<_Tp> _Node;   _Slist_iterator(_Node* __x) : _Slist_iterator_base(__x) {}  _Slist_iterator() : _Slist_iterator_base(0) {}  _Slist_iterator(const iterator& __x) : _Slist_iterator_base(__x._M_node) {}   reference operator*() const { return ((_Node*) _M_node)->_M_data; }  pointer operator->() const { return &(operator*()); }   _Self& operator++()  {    _M_incr();    return *this;  }   _Self operator++(int)  {    _Self __tmp = *this;    _M_incr();    return __tmp;  }};

3. slist设计
slist也是分层的设计，_Slist_base中定义了一个类型为_Slist_node_base的_M_head成员，head.next即指向链表的第一个节点。

template <class _Tp, class _Alloc> struct _Slist_base {  typedef _Alloc allocator_type;  allocator_type get_allocator() const { return allocator_type(); }   // 构造函数，将head.next置为空  _Slist_base(const allocator_type&) { _M_head._M_next = 0; }  // 析构函数, 通过调用_M_erase_after删除所有节点  ~_Slist_base() { _M_erase_after(&_M_head, 0); } protected:  typedef simple_alloc<_Slist_node<_Tp>, _Alloc> _Alloc_type;  _Slist_node<_Tp>* _M_get_node() { return _Alloc_type::allocate(1); }  void _M_put_node(_Slist_node<_Tp>* __p) { _Alloc_type::deallocate(__p, 1); }   // 删除指定节点后面的节点  _Slist_node_base* _M_erase_after(_Slist_node_base* __pos)  {    _Slist_node<_Tp>* __next = (_Slist_node<_Tp>*) (__pos->_M_next);    _Slist_node_base* __next_next = __next->_M_next;    __pos->_M_next = __next_next;    destroy(&__next->_M_data);    _M_put_node(__next);    return __next_next;  }   _Slist_node_base* _M_erase_after(_Slist_node_base*, _Slist_node_base*);protected:  _Slist_node_base _M_head;};   // 删除指定节点之后的节点：区间[before_first->next, last)template <class _Tp, class _Alloc> _Slist_node_base*_Slist_base<_Tp,_Alloc>::_M_erase_after(_Slist_node_base* __before_first,                                        _Slist_node_base* __last_node) {  _Slist_node<_Tp>* __cur = (_Slist_node<_Tp>*) (__before_first->_M_next);  while (__cur != __last_node) {    _Slist_node<_Tp>* __tmp = __cur;    __cur = (_Slist_node<_Tp>*) __cur->_M_next;    destroy(&__tmp->_M_data);    _M_put_node(__tmp);  }  __before_first->_M_next = __last_node;  return __last_node;}

slist基本结构定义：

template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >class slist : private _Slist_base<_Tp,_Alloc>{private:  typedef _Slist_base<_Tp,_Alloc> _Base; public:  typedef _Tp               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<_Tp, _Tp&, _Tp*>             iterator;  typedef _Slist_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;   typedef typename _Base::allocator_type allocator_type;   allocator_type get_allocator() const { return _Base::get_allocator(); } private:  typedef _Slist_node<_Tp>      _Node;  typedef _Slist_node_base      _Node_base;  typedef _Slist_iterator_base  _Iterator_base;   _Node* _M_create_node(const value_type& __x) {    _Node* __node = this->_M_get_node();    __STL_TRY {      construct(&__node->_M_data, __x);      __node->_M_next = 0;    }    __STL_UNWIND(this->_M_put_node(__node));    return __node;  }   _Node* _M_create_node() {    _Node* __node = this->_M_get_node();    __STL_TRY {      construct(&__node->_M_data);      __node->_M_next = 0;    }    __STL_UNWIND(this->_M_put_node(__node));    return __node;  } public:  iterator begin() { return iterator((_Node*)this->_M_head._M_next); }   iterator end() { return iterator(0); }   size_type size() const { return __slist_size(this->_M_head._M_next); }   size_type max_size() const { return size_type(-1); }   bool empty() const { return this->_M_head._M_next == 0; }   void swap(slist& __x)    { __STD::swap(this->_M_head._M_next, __x._M_head._M_next); } public:  reference front() { return ((_Node*) this->_M_head._M_next)->_M_data; }  void push_front(const value_type& __x)   {    __slist_make_link(&this->_M_head, _M_create_node(__x));  }   void pop_front() {    _Node* __node = (_Node*) this->_M_head._M_next;    this->_M_head._M_next = __node->_M_next;    destroy(&__node->_M_data);    this->_M_put_node(__node);  }   iterator previous(const_iterator __pos) {    return iterator((_Node*) __slist_previous(&this->_M_head, __pos._M_node));  } private:  _Node* _M_insert_after(_Node_base* __pos, const value_type& __x) {    return (_Node*) (__slist_make_link(__pos, _M_create_node(__x)));  } public:  void reverse() {     if (this->_M_head._M_next)      this->_M_head._M_next = __slist_reverse(this->_M_head._M_next);  }};

4. slist排序
slist的sort代码与list的sort代码非常类似。

template <class _Tp, class _Alloc>void slist<_Tp,_Alloc>::sort(){  if (this->_M_head._M_next && this->_M_head._M_next->_M_next) {    slist __carry;    slist __counter[64];    int __fill = 0;     while (!empty()) {      __slist_splice_after(&__carry._M_head,                           &this->_M_head, this->_M_head._M_next);      int __i = 0;      while (__i < __fill && !__counter[__i].empty()) {        __counter[__i].merge(__carry);        __carry.swap(__counter[__i]);        ++__i;      }      __carry.swap(__counter[__i]);      if (__i == __fill)        ++__fill;    }     for (int __i = 1; __i < __fill; ++__i)      __counter[__i].merge(__counter[__i-1]);    this->swap(__counter[__fill-1]);  }}