STL单链表slist简介

概述

slist（Single linked list）顾名思义，是一个单向链表，这个容器并不在标准规格之内，在我几年的代码学习生涯中也是第一次听说，既然侯老师的书中提到了，那也还是学习一蛤。

slist与list的主要差别是，前者的迭代器属于单向的Forward Iterator（可读写），后者的迭代器属于双向的Bidirectional Iterator（可以双向读写）。看起来slist的功能应该会不如list，但由于其单向链表的实现，其消耗的空间更小，某些操作更快。

回忆数据结构中在单链表的某个位置插入元素的过程，slist的底层实现就是单链表，因此会遇到我们曾经遇到过的麻烦：在某个位置插入时，必须要用一个指针从头到尾找到待插入位置的前一个位置。这便是在slist的一个大的缺点之一，因此，书中提到，在非起点位置使用insert或erase的算法是不智之举。

slist源码实现

在SGI STL源码中，slist的实现位于stl_slist.h中

节点设计

容器的核心就是其底层存储于迭代器设计了，对于节点设计，使用了继承的关系，实际上简单的来说就是单链表的节点：指向下一个节点的指针和数据

代码实现如下：

//stl_slist.h
//单向链表的节点结构
struct _Slist_node_base
{
  _Slist_node_base* _M_next;
};
//使用继承来实现单链表的节点结构：指针+数据
template <class _Tp>
struct _Slist_node : public _Slist_node_base
{
  _Tp _M_data;
};

基于单链表的特性和节点的结构，源码中提供了不少内部全局函数，这些函数不对外开放的，仅仅在某些对外使用的接口实现中直接调用，例如：

//全局函数：单链表节点数，其实就是简单的遍历计数
inline size_t __slist_size(_Slist_node_base* __node)
{
  size_t __result = 0;
  for ( ; __node != 0; __node = __node->_M_next)
    ++__result;
  return __result;
}
//全局函数：已知某一节点，插入新节点于其后
//返回插入节点之后的指针。
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;
}

迭代器设计

如上图所示，迭代器同样是使用了继承的方式：

//单向链表的迭代器基本结构
struct _Slist_iterator_base
{
  typedef size_t               size_type;
  typedef ptrdiff_t            difference_type;
  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; }
#ifndef __SGI_STL_NO_ARROW_OPERATOR
//->访问符重载，返回元素的地址的引用
  pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */

//前置++重载
  _Self& operator++()
  {
    _M_incr();//直接调用父类函数指针向后移动一位
    return *this;
  }
  //后置++重载
  _Self operator++(int)
  {
    _Self __tmp = *this;
    _M_incr();//直接调用父类函数指针向后移动一位
    return __tmp;
  }
  //这里没有--的重载，因为Forward Iterator的特性不支持双向操作
};

slist的数据结构

有了迭代器设计和节点设计的基础，单链表的实现就非常之简单了。虽然算法实现很简单，但是由于用到了继承关系，设计上看起来就有些复杂了：

//stl_slist.h
//父类定义了空间构造器等
template <class _Tp, class _Alloc>
struct _Slist_base {
  typedef _Alloc allocator_type;
  allocator_type get_allocator() const { return allocator_type(); }

  //构造函数，初始化指针
  _Slist_base(const allocator_type&) { _M_head._M_next = 0; }
  ~_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;//“头指针”，但事实上并不是指针
};  

#endif /* __STL_USE_STD_ALLOCATORS */

//根据代码来看，删除应该是前闭后开
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;
}

//stl_slist.h
template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
class slist : private _Slist_base<_Tp,_Alloc>
{
private:
  typedef _Slist_base<_Tp,_Alloc> _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;//返回指针
  }
  //创建元素值为0的节点(内部函数)
  _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;
  }
explicit slist(const allocator_type& __a = allocator_type()) : _Base(__a) {}//构造函数，指定空间配置器类型
//此外，还有许多用到其内部函数的构造函数，例如_M_insert_after_range等，这里就不一一列出。
};

除了上述简单介绍的构造和析构操作外，slist作为容器，它应该有一些容器统一的接口实现吧，根据STL的习惯，插入操作会将新元素插入于指定位置的前面，而非之后，作为一个单项链表，slist没有任何方便的办法可以回头定出前一个位置（没有prev指针），基于效率考虑，slist不提供push_back()只提供push_front()函数，这样插入顺序和元素次序就会相反。

//stl_slist.h
//首尾迭代器，包含头结点
  iterator begin() { return iterator((_Node*)this->_M_head._M_next); }
  const_iterator begin() const
    { return const_iterator((_Node*)this->_M_head._M_next);}

  iterator end() { return iterator(0); }
  const_iterator end() const { return const_iterator(0); }

  //调用内部函数求size大小
  size_type size() const { return __slist_size(this->_M_head._M_next); }

  //判断是否为空
  bool empty() const { return this->_M_head._M_next == 0; }

  //在头部插入元素
  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);
  }