stl标准库系列之--list

1、概述

list 容器，是序列容器的一种，是一个双向链表，因此又被称作双向链表容器。相较于vector的连续性空间来说，list会显得比较复杂。即该容器的底层是以双向链表的形式实现的。这意味着，list 容器中的元素可以分散存储在内存空间里，而不是必须存储在一整块连续的内存空间中。

可以看到，list 容器中各个元素的前后顺序是靠指针来维系的，每个元素都配备了 2 个指针，分别指向它的前一个元素和后一个元素。其中第一个元素的前向指针总为 null，因为它前面没有元素；同样，尾部元素的后向指针也总为 null。

基于这样的存储结构，list 容器具有一些其它容器（array、vector 和 deque）所不具备的优势，即它可以在序列已知的任何位置快速插入或删除元素（时间复杂度为O(1)）。并且在 list 容器中移动元素，也比其它容器的效率高。

使用 list 容器的缺点是，它不能像 array 和 vector 那样，通过位置直接访问元素。举个例子，如果要访问 list 容器中的第 6 个元素，它不支持容器对象名[6]这种语法格式，正确的做法是从容器中第一个元素或最后一个元素开始遍历容器，直到找到该位置。

2、节点 node

既然list是一个双向链表，那么我们就不得不了解下list的结点。

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;
};

我们最常见的版本。

template <class _T>
struct _List_node{
    typedef void* void_pointer;
    _T _data;
    void_pointer prev;	//可设置为_List_node<_T>*
    void_pointer next;
};

3、定义

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) {
    _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;
}

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 _List_node<_Tp> _Node;
}

上面代码是SGI 版本STL源码中list的定义，我们将上面这段代码简化一下。

template <class T, class Alloc = alloc>	//缺省使用 alloc 为配置器
class list{
protected:
	typedef _List_node<T> list_node;
public:
	typedef _List_iterator<_Tp,_Tp&,_Tp*>             iterator;
  	typedef _List_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
}

上面是简化后的版本。SGI 版本的list是个环状的双向链表。

为了方便的实现list模板类提供的函数，该模板在为了更方便的实现 list 模板类提供的函数，该模板类在构建容器时，会刻意在容器链表中添加一个空白节点，并作为 list 链表的首个节点（又称头节点）。

比如我们常常实现的创建一个没有任何元素的list容器。

public:
	list(){ empty_initialize(); }	//创建一个空的list容器
	
protected:
	void empty_initialize()
	{
		node = get_node();	//配置一个节点空间，令node指向它
		node->next = node;	//令node头尾都指向自己
		node->prev = node;
	}

4、特点

• 内存不一定是连续性的
• 不支持随机存取，只能直接存取首尾的元素，想要获取到其他的元素，只能通过遍历的方式
• 在任何位置插入或者删除，时间复杂度都是常数级的（O(n)）。因为在操作的时候，不需要移动和删除其他的元素
• 插入和删除不会造成指向其他元素的 iterator、pointer、reference失效
• list对异常操作的处理方式：要么成功，要么什么都不发生

5、创建方法

list以类模板list的形式定义在中，并且位于std命名空间中。因此，使用之前需要包含：

#include 
using namespace std;

• 创建一个没有任何元素的空 list 容器：

  std::list<int> data;
  

  和空 array 容器不同，空的 list 容器在创建之后仍可以添加元素，因此创建 list 容器的方式很常用。

• 创建一个包含 n 个元素的 list 容器：

  std::list<int> data(10);
  

  通过此方式创建 data容器，其中包含 10 个元素，每个元素的值都为相应类型的默认值（int类型的默认值为 0）。

• 创建一个包含 n 个元素的 list 容器，并为每个元素指定初始值：

  std::list<int> data(10, 5);
  

• 在已有 list 容器的情况下，通过拷贝该容器可以创建新的 list 容器:

  std::list<int> data1(10);
  std::list<int> data2(data1);
  

  注意：通过拷贝容器的方式新建容器，则一定要保证两个容器的元素的类型一致。

• 通过拷贝其他类型容器（或者普通数组）中指定区域内的元素，可以创建新的 list 容器：

  //拷贝普通的数组，创建 list 容器
  int a[] = { 1,2,3,4,5 };
  std::list<int> values(a, a+5);
  
  //拷贝其它类型的容器，创建 list 容器
  std::array<int, 5>arr{ 11,12,13,14,15 };
  std::list<int>values(arr.begin()+2, arr.end());//拷贝arr容器中的{13,14,15}
  

6、内存管理

我们还是以一个比较简单的例子来看下list在增、删之后的大小情况。

#include 
#include 
#include 

using namespace std;

int main(int argc, char* argv[])
{
	list<int> data;
	cout << "list size = " << data.size() << endl;	//list size = 0 创建的是大小为0的list 
	
	for(int nIndex = 1; nIndex <= 5; ++nIndex)
	{
		data.push_back(nIndex);	
	}
	
	cout << "list size = " << data.size() << endl;	//list size = 5，大小是动态创建的，每push一个成员就新增一个成员的大小 
	
	list<int>::iterator itor = data.begin();
	for(; itor != data.end(); ++itor)
	{
		cout << *itor << " ";	// 1 2 3 4 5 
	}
	cout << endl;
	
	itor = find(data.begin(), data.end(), 3);
	
	if(itor != data.end())
	{
		data.insert(itor, 10);	
	}
	
	itor = data.begin();
	for(; itor != data.end(); ++itor)
	{
		cout << *itor << " ";	// 1 2 10 3 4 5 
	}
	cout << endl;
	
	cout << "list size = " << data.size() << endl;	//list size = 6
	
	itor = find(data.begin(), data.end(), 3);
	if(itor != data.end())
	{
		itor = data.erase(itor);	//删除是可以返回下一个元素的迭代器的 
	}
	
	cout << "list size = " << data.size() << endl;	// list size = 5
	cout << *itor <<endl;	// 4 下一个元素 
	
	return 0;
}

由上面的例子我们可以看出：

• 空的list的大小为0；当通过push_back在尾部插入元素时，list容器的大小相应的改变，使用erase删除一个元素后，大小相应改变
• 给list容器中插入元素，插入之后的新元素在迭代器（哨兵）的前面，这是STL对于插入操作的标准规范
• 进行元素删除时，指向其他元素的迭代器并没有失效，使用erase函数时会返回下一个元素的迭代器

7、成员函数

函数	说明
void push_front(const T & val)	将 val 插入链表最前面
void pop_front()	删除链表最前面的元素
void sort()	将链表从小到大排序
void remove (const T & val)	删除和 val 相等的元素
remove_if	删除符合某种条件的元素
void unique()	删除所有和前一个元素相等的元素
void merge(list & x)	将链表 x 合并进来并清空 x。要求链表自身和 x 都是有序的
void splice(iterator i, list & x, iterator first, iterator last)	在位置 i 前面插入链表 x 中的区间 [first, last)，并在链表 x 中删除该区间。 链表自身和链表 x 可以是同一个链表，只要 i 不在 [first, last) 中即可
void transfer(iterator position, iterator first, iterator last)	将[first, last)连续范围内的元素全部移到某个特定的位置（position）之前 该区间可在同一个list中

list容器的成员函数大多数和vector的功能一样，这边就不在一一赘述，有需要的可以翻翻上一篇看看。

• list容器成员函数中增加了sort()，这是因为STL的sort()函数需要随机访问迭代器的支持。而list不支持。
• list内部提供了一个迁移操作的函数，该函数是未公开的接口。

8、迭代器

list由于其节点不保证在存储空间的连续性。因此，不能想vector一样以普通指针做为迭代器。list的迭代器必须有能力指向list的节点。并且能够进行正常的递增、递减、取值，元素存取等操作。

STL中list容器是双向链表，因此迭代器必须具备前移、后移的能力，所以list的迭代器是双向迭代器（Bidirectional iterators）.

list 的特性，增加的操作并不会影响原来迭代器失效，删除时也只是“指向被删除元素”那个迭代器失效。

struct _List_iterator_base {
  typedef size_t                     size_type;
  typedef ptrdiff_t                  difference_type;
  typedef bidirectional_iterator_tag iterator_category;

  _List_node_base* _M_node;

  _List_iterator_base(_List_node_base* __x) : _M_node(__x) {}
  _List_iterator_base() {}

  void _M_incr() { _M_node = _M_node->_M_next; }
  void _M_decr() { _M_node = _M_node->_M_prev; }

  bool operator==(const _List_iterator_base& __x) const {
    return _M_node == __x._M_node;
  }
  bool operator!=(const _List_iterator_base& __x) const {
    return _M_node != __x._M_node;
  }
};

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;
  }
};

从一张图来看看list的迭代器。