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_node
template <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代码非常类似，可以参考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]);
  }
}

至此，STL常见序列容器基本分析完毕，接下来准备看看关联容器，以及记录一下使用STL过程中遇到的一些“坑”（比如最近使用sort导致了core dump）。

原文链接：http://www.programlife.net/stl-slist.html，作者：代码疯子