STL源码阅读-list

相比于vector，list在内存使用上更加精细，并且list在任何位置插入数据，都是常量时间。

list的部分基本定义如下：

template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
class list : protected _List_base<_Tp, _Alloc> {
  // requirements:

  __STL_CLASS_REQUIRES(_Tp, _Assignable);

  typedef _List_base<_Tp, _Alloc> _Base;
protected:
  typedef void* _Void_pointer;

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 _List_node<_Tp> _Node;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

  typedef typename _Base::allocator_type allocator_type;
  allocator_type get_allocator() const { return _Base::get_allocator(); }

public:
  typedef _List_iterator<_Tp,_Tp&,_Tp*>             iterator;
  typedef _List_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;

#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
  typedef reverse_iterator<const_iterator> const_reverse_iterator;
  typedef reverse_iterator<iterator>       reverse_iterator;
#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  typedef reverse_bidirectional_iterator<const_iterator,value_type,
                                         const_reference,difference_type>
          const_reverse_iterator;
  typedef reverse_bidirectional_iterator<iterator,value_type,reference,
                                         difference_type>
          reverse_iterator; 
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

protected:
#ifdef __STL_HAS_NAMESPACES
  using _Base::_M_node;
  using _Base::_M_put_node;
  using _Base::_M_get_node;
#endif /* __STL_HAS_NAMESPACES */

protected:
  _Node* _M_create_node(const _Tp& __x)
  {
    _Node* __p = _M_get_node();
    __STL_TRY {
      _Construct(&__p->_M_data, __x);
    }
    __STL_UNWIND(_M_put_node(__p));
    return __p;
  }

  _Node* _M_create_node()
  {
    _Node* __p = _M_get_node();
    __STL_TRY {
      _Construct(&__p->_M_data);
    }
    __STL_UNWIND(_M_put_node(__p));
    return __p;
  }

public:
  explicit list(const allocator_type& __a = allocator_type()) : _Base(__a) {}

  iterator begin()             { return (_Node*)(_M_node->_M_next); }
  const_iterator begin() const { return (_Node*)(_M_node->_M_next); }

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

  reverse_iterator rbegin() 
    { return reverse_iterator(end()); }
  const_reverse_iterator rbegin() const 
    { return const_reverse_iterator(end()); }

  reverse_iterator rend()
    { return reverse_iterator(begin()); }
  const_reverse_iterator rend() const
    { return const_reverse_iterator(begin()); }

  bool empty() const { return _M_node->_M_next == _M_node; }
  size_type size() const {
    size_type __result = 0;
    distance(begin(), end(), __result);
    return __result;
  }
  size_type max_size() const { return size_type(-1); }

  reference front() { return *begin(); }
  const_reference front() const { return *begin(); }
  reference back() { return *(--end()); }
  const_reference back() const { return *(--end()); }

从list的定义里面可以看到，list采用的是stl的alloc作为内存空间的分配，因此在进行内存分配的时候，实际上是会略多于需要的内存空间的，存在一定的空间浪费，哈哈，这个确实有点吹毛求疵了。

与vector不同，list里面的Tp* 是pointer，而不是iterator，list需要对pointer进行封装，才能符合iterator的定义。

list继承自_List_base,_List_base的定义如下：

template <class _Tp, class _Alloc>
class _List_base 
{
public:
  typedef _Alloc allocator_type;
  allocator_type get_allocator() const { return allocator_type(); }

  _List_base(const allocator_type&) {
    _M_node = _M_get_node();//分配一个节点
    _M_node->_M_next = _M_node;//构成一个环
    _M_node->_M_prev = _M_node;
  }
  ~_List_base() {
    clear();
    _M_put_node(_M_node);
  }

  void clear();

protected:
  typedef simple_alloc<_List_node<_Tp>, _Alloc> _Alloc_type;
  _List_node<_Tp>* _M_get_node() { return _Alloc_type::allocate(1); }
  void _M_put_node(_List_node<_Tp>* __p) { _Alloc_type::deallocate(__p, 1); } 

protected:
  _List_node<_Tp>* _M_node;
};

#endif /* __STL_USE_STD_ALLOCATORS */

template <class _Tp, class _Alloc>
void 
_List_base<_Tp,_Alloc>::clear() 
{
  _List_node<_Tp>* __cur = (_List_node<_Tp>*) _M_node->_M_next;
  while (__cur != _M_node) {//构成了环，所以不是__cur!=NULL
    _List_node<_Tp>* __tmp = __cur;
    __cur = (_List_node<_Tp>*) __cur->_M_next;
    _Destroy(&__tmp->_M_data);
    _M_put_node(__tmp);
  }
  _M_node->_M_next = _M_node;
  _M_node->_M_prev = _M_node;
}

_list_base里面是一些基本的操作，包括初始化之类的，clear函数中由于list的节点构成了一个环，因此在判断是否是到了链表的结尾。

list_base中采用的节点是_list_node，这个结构体的定义如下：

struct _List_node_base {
  _List_node_base* _M_next;
  _List_node_base* _M_prev;
};

template <class _Tp>
struct _List_node : public _List_node_base {
  _Tp _M_data;
};

可以看出来，list_node节点是一个双向链表，在看到这个定义之前，我在想STL怎么将这个list_node_base与tp_M_data帮顶起来，也就是说如果知道list_node_base的地址，怎么获得_Tp_M_data的地址，在linux 内核里面，有一种很精妙的方式，就是判断_Tp_M_data相对于0的位置，然后利用list_node_base加上这个差值，就可以得到需要的_Tp_M_data的位置。 这个里面采用继承的方式，也能够得到同样的效果。

上面_List_base在进行内存空间分配的时候，采用的是simple_alloc，不过其实质是一样的，都是采用_Alloc作为分配选择的。

 typedef simple_alloc<_List_node<_Tp>, _Alloc> _Alloc_type;//采用simple_alloc作为内存分配的方式
  _List_node<_Tp>* _M_get_node() { return _Alloc_type::allocate(1); }

simple_alloc的详细定义如下：

template<class _Tp, class _Alloc>
class simple_alloc {

public:
    static _Tp* allocate(size_t __n)
      { return 0 == __n ? 0 : (_Tp*) _Alloc::allocate(__n * sizeof (_Tp)); }
    static _Tp* allocate(void)
      { return (_Tp*) _Alloc::allocate(sizeof (_Tp)); }
    static void deallocate(_Tp* __p, size_t __n)
      { if (0 != __n) _Alloc::deallocate(__p, __n * sizeof (_Tp)); }
    static void deallocate(_Tp* __p)
      { _Alloc::deallocate(__p, sizeof (_Tp)); }
};

可以看到simple_alloc基本上是对_Alloc的简单封装吧。

到这里基本上list的节点内存分配应该就差不多了。

看一下list的一些关键操作。

front和back

reference front() { return *begin(); }
  const_reference front() const { return *begin(); }
  reference back() { return *(--end()); }
  const_reference back() const { return *(--end()); }

可以看到 front 和back是直接调用begin，以及end，而begin和end 返回的是iterator，这个地方没看错了，以为返回的是指针，很纳闷为什么--end()能这么干。。。。

iterator的定义如下：

template<class _Tp, class _Ref, class _Ptr>
struct _List_iterator : public _List_iterator_base {
  typedef _List_iterator<_Tp,_Tp&,_Tp*>             iterator;
  typedef _List_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
  typedef _List_iterator<_Tp,_Ref,_Ptr>             _Self;

  typedef _Tp value_type;
  typedef _Ptr pointer;
  typedef _Ref reference;
  typedef _List_node<_Tp> _Node;

  _List_iterator(_Node* __x) : _List_iterator_base(__x) {}
  _List_iterator() {}
  _List_iterator(const iterator& __x) : _List_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++() { 
    this->_M_incr();
    return *this;
  }
  _Self operator++(int) { 
    _Self __tmp = *this;
    this->_M_incr();
    return __tmp;
  }
  _Self& operator--() { 
    this->_M_decr();
    return *this;
  }
  _Self operator--(int) { 
    _Self __tmp = *this;
    this->_M_decr();
    return __tmp;
  }
};

就是将pointer的操作进行了封装，从而符合iterator的要求。

list的插入、删除、合并、拆分，算是比较重要的。

insert函数：

 iterator insert(iterator __position, const _Tp& __x) {
    _Node* __tmp = _M_create_node(__x);//申请空间
    __tmp->_M_next = __position._M_node;
    __tmp->_M_prev = __position._M_node->_M_prev;
    __position._M_node->_M_prev->_M_next = __tmp;
    __position._M_node->_M_prev = __tmp;
    return __tmp;
  }

典型的链表插入，分配一个存储空间，然后调整pre和next指针就可以了。

一个重要的函数，transfer，将[first,last)之间的数据移动到position之前

  void transfer(iterator __position, iterator  __first  , iterator __last) {
    if (__position != __last) {
      // Remove [first, last) from its old position.
      __last._M_node->_M_prev->_M_next     = __position._M_node;
      __first._M_node->_M_prev->_M_next    = __last._M_node;
      __position._M_node->_M_prev->_M_next = __first._M_node; 

      // Splice [first, last) into its new position.
      _List_node_base* __tmp      = __position._M_node->_M_prev;
      __position._M_node->_M_prev = __last._M_node->_M_prev;
      __last._M_node->_M_prev     = __first._M_node->_M_prev; 
      __first._M_node->_M_prev    = __tmp;
    }
  }

这个就是移动指针。后面在很多地方有用到。

由于list不能提供RandomAccessIterator，所以list不能使用STL的sort，必须使用自己的sort函数。list的sort采用quicksort排序算法。

template <class _Tp, class _Alloc>
void list<_Tp, _Alloc>::sort()
{
  // Do nothing if the list has length 0 or 1.
  if (_M_node->_M_next != _M_node && _M_node->_M_next->_M_next != _M_node) {
    list<_Tp, _Alloc> __carry;
    list<_Tp, _Alloc> __counter[64];
    int __fill = 0;
    while (!empty()) {
      __carry.splice(__carry.begin(), *this, begin());
      int __i = 0;
      while(__i < __fill && !__counter[__i].empty()) {
        __counter[__i].merge(__carry);
        __carry.swap(__counter[__i++]);
      }
      __carry.swap(__counter[__i]);         
      if (__i == __fill) ++__fill;
    } 

    for (int __i = 1; __i < __fill; ++__i)
      __counter[__i].merge(__counter[__i-1]);
    swap(__counter[__fill-1]);
  }

这个算法看了一下，侯捷在《STL源码解析》这本书中说这个算法是quick sort，怎么看都感觉不对，然后就仔细比对了一下，查了一些资料，这个算法应该还是属于归并排序，以1 4  3 6 7 2 这样一个序列为例，其排序过程为：

第一轮过后： counter[0] = {1}, carry = {}, counter[1] = {}, fill = 1; list={4,3,6,7,2}

第二轮过后： counter[0] = {}，carry = {}, counter[1] = {1,4},fill = 2; list={3,6,7,2}

第三轮过后 ：counter[0] = {3},carry={},counter[1] = {1,4}.fill = 2; list={6,7,2}

第四轮过后：counter[0] = {0},carry={},counter[1]= {},counter[2] ={1,3,4,6},fill = 3,list={7,2}；

第五轮过后： counter[0] = {7};carry={},counter[1]= {},counter[2] ={1,3,4,6},fill = 3,list={2}；

第六轮过后：counter[0] = {};carry={2,7},counter[1]= {},counter[2] ={1,3,4,6},fill = 3,list={}；

然后就跳出了while循环，进入 下面代码

 for (int __i = 1; __i < __fill; ++__i)
      __counter[__i].merge(__counter[__i-1]);

下面代码一次从0-3合并所有的序列，这样最终就得到了123467。最后进行carry和list交换，就完成排序过程了。 按照这个计算，由于总共有64个队列，所以最多能够排序的队列长度为2^64-1个数据，这个数据应该算是很庞大的，所以算法能够保持有效。这个算法确实写的比较精妙。