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，同时拥有一个存储数据的成员。
1 2 3 4 5 6 7 8 9 10 11 12 | // 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指针类型。可以看到因为单链表只能往后迭代，所以很多操作都没有提供，即使提供了，也是非常低效的操作，需要从头结点开始遍历。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 | // 在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++操作。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 | // 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即指向链表的第一个节点。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 | 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基本结构定义：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 | 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一节。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | 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）。
STL源码剖析笔记系列
1. STL笔记之空间配置器
2. STL笔记之迭代器
3. STL笔记之vector
4. STL笔记之list
5. STL笔记之优先队列
6. STL笔记之deque
7. STL笔记之slist
本文地址: 程序人生 >> STL笔记之slist
作者：代码疯子（Wins0n） 本站内容如无声明均属原创，转载请保留作者信息与原文链接，谢谢！