【C++】：STL序列式容器list源码剖析

在这里插入图片描述

一、list概述

总的来说：环形双向链表
特点：
底层是使用链表实现的，支持双向顺序访问
在list中任何位置进行插入和删除的速度都很快
不支持随机访问，为了访问一个元素，必须遍历整个容器
与其他容器相比，额外内存开销大
设计目的：令容器在任何位置进行插入和删除都很快
何时使用：
容器需要不断地在中间插入或删除元素
无论删除还是增加，list的迭代器、引用、指针都不会失效
与其他容器的比较：
在这里插入图片描述

二、list的节点（__list_node）

list的每个节点是一个结构体。以下是list的节点（node）结构：
源码：

template <class T>
struct __list_node {typedef void* void_pointer;void_pointer prev; //类型为void*。其实可设为__list_node<T>*void_pointer next;T data;
};

下图是结构所示的样子
在这里插入图片描述

三、list的迭代器

list不再能够 vector一样以原生指标做为迭代器，因为其节点不保证在储存空间中连续存在
list迭代器必须有能力指向list的节点，并有能力做正确的递增、递减、取值、成员存取等动作。所谓“list迭代器正确的递增、递减、取值、成员取用”动作是指：递增时指向下一个节点，递减时指向上一个节点，取值时取的是节点的数据值，成员取用时取用的是节点的成员，如下图所示：
在这里插入图片描述
由于list是一个双向链表（double linked-list），迭代器必须具备前移、后移的能力。所以list提供的是Bidirectional Iterators
list有以下几个重要性质：
插入动作（insert）和接合动作（splice）都不会造成原有的 list 迭代器失效。这在vector是不成立的，因为 vector的插入动作可能造成记忆体重新配置，导致原有的迭代器全部失效
甚至list的元素删除动作（erase），也只有“指向被删除元素”的那个迭代器失效，其他迭代器不受任何影响
迭代器源码：

template<class T, class Ref, class Ptr>
struct list_iterator {typedef list_iterator<T, T&, T*> iterator;typedef list_iterator<T, Ref, Ptr> self;typedef bidirectional_iterator_tag iterator_category;typedef T value_type;typedef Ptr pointer;typedef Ref reference;typedef list_node<T>* link_type;typedef size_t size_type;typedef ptrdiff_t difference_type;link_type node; / 迭代器内部当然要有一个原生指标，指向list的节点// constructorlist_iterator(link_type x) : node(x) {}list_iterator() {}list_iterator(const iterator& x) : node(x.node) {}bool operator==(const self& x) const { return node == x.node; }bool operator!=(const self& x) const { return node != x.node; }// 以下对迭代器取值（dereference），取的是节点的数据值reference operator*() const { return (*node).data; }// 以下是迭代器的成员存取（member access）运算子的标准作法pointer operator->() const { return &(operator*()); }//对迭代器累加1，就是前进一个节点self& operator++()node = (link_type)((*node).next);return *this;}self operator++(int)self tmp = *this;++*this;return tmp;}//对迭代器递减1，就是后退一个节点self& operator--()node = (link_type)((*node).prev);return *this;}self operator--(int)self tmp = *this;--*this;return tmp;}
};

四、list的数据结构

list不仅是一个双向串行，而且还是一个环状双向链表。所以它只需要一个指针，便可以完整表现整个链表
link_type、node节点：node节点是指向于list最后一个节点的指针

template <class T, class Alloc = alloc> //默认使用alloc为配置器
class list {
protected:typedef __list_node<T> list_node;
public:typedef list_node* link_type;
protected:link_type node; // 只要一个指针，便可表示整个环状双向链表
...
};

begin()、end()等函数：如果让指标node指向刻意置于尾端的一个空白节点，node便能符合STL对于“前闭后开”区间的要求，成为last迭代器，如下图所示。这么一来，以几个函数便都可以轻易完成：

iterator begin() { return (link_type)((*node).next); }iterator end() { return node; }bool empty() const { return node->next == node; }size_type size() const {size_type result = 0;distance(begin(), end(), result); // 全局函式，第 3章。return result;
}// 取头节点的内容（元素值）
reference front() { return *begin(); }// 取尾节点的内容（元素值）
reference back() { return *(--end()); }

在这里插入图片描述

五、list的构造与内存管理（constructor、push_back、insert）

list的内存管理（list_node_allocator）：list缺省使用alloc做为空间配置器，并据此另外定义了一个list_node_allocator，为的是更方便地以节点大小为配置单位：

template <class T, class Alloc = alloc> //默认使用alloc为配置器
class list {
protected:typedef __list_node<T> list_node;// 专属之空间配置器，每次配置一个节点大小：typedef simple_alloc<list_node, Alloc> list_node_allocator;...
};

于是，list_node_allocator(n) 表示配置n个节点空间。以下四个函数，分别用来配置、释放、建构、摧毁一个节点：

protected:// 配置一个节点并传回link_type get_node() { return list_node_allocator::allocate(); }// 释放一个节点voidput_node(link_typep){list_node_allocator::deallocate(p);}// 产生（配置并构造）一个节点，带有元素值link_type create_node(const T& x) {link_type p = get_node();construct(&p->data, x);//全局函数，构造/析构基本工具return p;}// 摧毁（解构并释放）一个节点void destroy_node(link_type p) {destroy(&p->data); //全局函数，构造/析构基本工具put_node(p);}

构造函数：list 提供有许多constructors，其中以个是default constructor，允许我们不指定任何参数做出一个空的list出来：

public:list() { empty_initialize(); } //产生一个空链表
protected:void empty_initialize()node = get_node(); //配置一个节点空间，令node指向它node->next = node; //令node头尾都指向自己，不设元素值node->prev = node;
}

list为空时， node节点的prev、next指向于自己
push_back、insert：当我们以push_back()将新元素插入于list尾端，此函数内部调用insert()：

void push_back(const T& x) { insert(end(), x); }

insert()是一个重载函数，有多种形式，其中最简单的以种如下，符合以上所需。首先配置并构造一个节点，然后在尾端进行适当的指针动作，将新节点插入进去：

//函数目的：在迭代器 position 所指位置插入一个节点，内容为x
iterator insert(iterator position, const T& x) {link_type tmp = create_node(x);//产生一个节点（设妥内容为x）//调整双向指针，使 tmp插入进去tmp->next = position.node;tmp->prev = position.node->prev;(link_type(position.node->prev))->next = tmp;position.node->prev = tmp;return tmp;
}

于是，如果程序连续插入了五个节点（其值为0、1、2、3、4）之后，list的状态如下图所示
在这里插入图片描述

如果我们希望在list内的某处安插新节点，首先必须确定安插位置，例如我希望在数据值为3的节点处插入一个数据值为99的节点，可以这么做：

ilite = find(il.begin(), il.end(), 3);
if (ilite!=0)il.insert(ilite, 99);

在这里插入图片描述

六、list的元素操作

push_front、push_back：

//插入一个节点，做为头节点
void push_front(const T& x) { insert(begin(), x); }//插入一个个节点，做为尾节点
void push_back(const T& x) { insert(end(), x); }

erase：

//移除迭代器position所指节点
iterator erase(iterator position) {link_type next_node = link_type(position.node->next);link_type prev_node = link_type(position.node->prev);prev_node->next = next_node;next_node->prev = prev_node;destroy_node(position.node);return iterator(next_node);
}

由于list是一个双向环状链表，只要我们把边际条件处理好，那么，在头部或尾部插入元素（push_front 和 push_back），动作几乎是一样的，在头部或尾部移除元素（pop_front和pop_back），动作也几乎是一样的。移除（erase）某个迭代器所指元素，只是做一些指针搬移动作而已，并不复杂。如果上图再经以下搜寻并移除的动作，状况将如下图所示

ite = find(ilist.begin(), ilist.end(), 1);
if (ite!=0)cout << *(ilist.erase(ite)) << endl;

在这里插入图片描述
pop_front、pop_back：

//移除头节点
void pop_front() { erase(begin()); }//移除尾节点
void pop_back()iterator tmp = end();erase(--tmp);
}

clear：

// 清除所有节点（整个链表）
template <class T, class Alloc>
void list<T, Alloc>::clear()
{link_type cur = (link_type) node->next; //begin()while (cur != node) { //遍历每一个节点link_type tmp = cur;cur = (link_type) cur->next;destroy_node(tmp); // 销毁（析构并释放）一个节点}//恢复node原始状态node->next = node;node->prev = node;
}

remove：

//将数值为value之所有元素移除
template <class T, class Alloc>
void list<T, Alloc>::remove(const T& value) {iterator first = begin();iterator last = end();while (first != last) { //遍历每一个节点iterator next = first;++next;if (*first == value) erase(first); //找到就移除first = next;}
}

unique：

//移除数值相同的连续元素。注意，只有“连续而相同的元素”，才会被移除剩一个
template <class T, class Alloc>
void list<T, Alloc>::unique()
{ iterator first = begin();iterator last = end();if (first == last) return; //空链表，什么都不必做iterator next = first;while (++next != last) { //遍历每一个节点if (*first == *next) //如果在此区段中有相同的元素erase(next); //移除之elsefirst = next; //调整指针next = first; //修正区段范围}
}

transfer：
list内部提供一个所谓的迁移动作（transfer）：将某连续范围的元素迁移到某个特定位置之前。技术上很简单，节点间的指针移动而已
这个动作为其他的复杂动作如splice, sort, merge等奠定良好的基础
下面是transfer的源码，transfer不是公开接口：

protected:
//将[first,last)内的所有元素搬移到position之前
void transfer(iterator position, iterator first, iterator last) {if (position != last) {(*(link_type((*last.node).prev))).next = position.node;   // (1)(*(link_type((*first.node).prev))).next = last.node;      // (2)(*(link_type((*position.node).prev))).next = first.node;  // (3)link_type tmp = link_type((*position.node).prev);         // (4)(*position.node).prev = (*last.node).prev;                // (5)(*last.node).prev = (*first.node).prev;                   // (6)(*first.node).prev = tmp;                                 // (7)}
}

以上七个动作，如下图所示
在这里插入图片描述
splice：上述的transfer并非公开接口。 list公开提供的是所谓的接合动作（splice）：将某连续范围的元素从一个list搬移到另一个（或同一个）list 的某个定点。下面是一个演示案例：

int iv[5] = { 5,6,7,8,9 };
list<int> ilist2(iv, iv+5);//假设ilist的内容为0 2 99 3 4
ite = find(ilist.begin(), ilist.end(), 99);ilist.splice(ite,ilist2); // 0 2 5 6 7 8 9 99 3 4
ilist.reverse();          // 4 3 99 9 8 7 6 5 2 0
ilist.sort();             // 0 2 3 4 5 6 7 8 9 99

很容易便可看出效果。下图显示接合动作。技术上很简单，只是节点间的指针移动而已，这些动作已完全由transfer()做掉了
为了提供各种接口弹性，list::splice有许多版本：

public://将x接合于position所指位置之前。x必须不同于*thisvoid splice(iterator position, list& x) {if (!x.empty())transfer(position, x.begin(), x.end());}//将i所指元素接合于position所指位置之前。position和i可指向同一个listvoid splice(iterator position, list&, iterator i) {iterator j = i;++j;if (position == i || position == j) return;transfer(position, i, j);}//将[first,last) 内的所有元素接合于 position 所指位置之前//position 和[first,last)可指向同一个list，//但position不能位于[first,last)之内void splice(iterator position, list&, iterator first, iterator last) {if (first != last)transfer(position, first, last);}

以下是 merge(), reverse(), sort()的源码。有了transfer()在手，这些动作都不难完成
merge()：

// merge()将x合并到*this身上。两个lists的内容都必须先递增排序
template <class T, class Alloc>
void list<T, Alloc>::merge(list<T, Alloc>& x) {iterator first1 = begin();iterator last1 = end();iterator first2 = x.begin();iterator last2 = x.end();// 注意：前提是，两个lists都已经经过递增排序while (first1 != last1 && first2 != last2)if (*first2 < *first1) { iterator next = first2; transfer(first1,first2, ++next);first2 = next;}else++first1;if (first2 != last2) transfer(last1, first2, last2);
}

reverse()：

//reverse()将*this的内容逆向重置
template <class T, class Alloc>
void list<T, Alloc>::reverse() {//以下判断，如果是空链表，或仅有一个元素，就不做任何动作//使用 size() == 0 || size() == 1 来判断，虽然也可以，但是比较慢if (node->next == node || link_type(node->next)->next == node)return;iterator first = begin();++first;while (first != end()) {iterator old = first;++first;transfer(begin(), old, first);}
}

sort()：

//list不能使用STL算法sort()，必须使用自己的sort() member function，
//因为STL算法 sort()只接受RamdonAccessIterator.
//本函数采用 quick sorttemplate <class T, class Alloc>
void list<T, Alloc>::sort() {// 以下判断，如果是空链表，或仅有一个元素，就不做任何动作// 使用 size() == 0 || size() == 1 来判断，虽然也可以，但是比较慢if (node->next == node || link_type(node->next)->next == node)return;//一些新的lists，做为中介数据存放区list<T, Alloc> carry;list<T, 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]);
}