STL之list源码剖析

STL之list源码剖析

相较于vector，使用list的好处是每次插入或删除一个元素，就配置或释放一个元素的空间。

list的节点：

template<class T>

struct __list_node{

typedefvoid* void_pointer;

void_pointerprev; //型别为void*。其实可设为__list_node<T>*

void_pointernext;

Tdata;

};

显然这是一个双向链表。

list迭代器

list不再能够像vector一样以普通指针作为迭代器，因为其节点不保证在存储空间中连续。List迭代器必须有能力指向list的节点，并有能力进行正确的递增、递减、取值、成员存取等操作。

由于STL list是一个双向链表，迭代器必须具备前移、后移的能力，所以list提供的是bidirectional Iterators。

list有一个重要性质:插入操作和结合操作都不会造成原有的list迭代器失效，甚至删除操作也只有”指向被删除元素”的那个迭代器失效，其他迭代器不受影响。

以下是list迭代器的设计：

template<class T, class Ref, class Ptr>

struct __list_iterator {

typedef__list_iterator<T, T&, T*>iterator;

typedef__list_iterator<T, const T&, const T*> const_iterator;

typedef__list_iterator<T, Ref, Ptr>self;

typedefbidirectional_iterator_tag iterator_category;

typedefT value_type;

typedefPtr pointer;

typedefRef reference;

typedef__list_node<T>* link_type;

typedefsize_t size_type;

typedefptrdiff_t difference_type;

link_type node;

__list_iterator(link_type x) : node(x) {}

__list_iterator() {}

__list_iterator(const iterator& x) : node(x.node) {}

booloperator==(const self& x) const { return node == x.node; }

bool operator!=(constself& x) const { return node != x.node; }

reference operator*() const { return (*node).data; }

#ifndef __SGI_STL_NO_ARROW_OPERATOR

pointeroperator->() const { return &(operator*()); }

#endif /* __SGI_STL_NO_ARROW_OPERATOR */

self& operator++() {

node= (link_type)((*node).next);

return *this;

}

selfoperator++(int) {

selftmp = *this;

++*this;

return tmp;

}

self& operator--() {

node= (link_type)((*node).prev);

return *this;

}

selfoperator--(int) {

selftmp = *this;

--*this;

return tmp;

}

};

list的数据结构

list不仅是一个双向链表，而且还是一个环状双向链表。所以他只需要一个指针，便可以完整表现整个链表：

template<class T,class Alloc= alloc> //缺省使用alloc为配置器

classlist{

protected:

typedef __list_node<T> list_node;

public:

typedef list_node* link_type;

protected:

link_typenode; //只要一个指针，便可表示整个环状双向链表

...

};

让指针node指向置于尾端的一个空白节点,node变能符合STL对于”前开后闭”区间的要求，成为last（或者说end()）迭代器。

如下图所示：

于是，以下几个函数便可以轻松完成：

iterator begin(){ return (link_type)((*node).next); }

iterator end(){ returnnode; }

boolempty() const { returnnode->next == node; }

size_type size() const{

size_typereslut = 0;

distance(begin(),end(), result);

return result;

}

//取头结点的内容(元素值)

reference front(){ return *begin(); }

//取尾节点的内容(元素值)

reference back(){ return *(--end()); }

list的构造与内存管理：

list缺省使用alloc作为空间配置器，并据此另外定义了一个list_node_allocator，为方便以节点大小为配置单位：

template <class T, class Alloc = alloc>

class list{

protected:

typedef__list_node<T> list_node;

typedefsimple_alloc<list_node, Alloc>list_node_allocator;

…

};

以下四个函数用来配置、释放、构造、销毁一个节点：

protected:

link_type get_node() { return list_node_allocator::allocate(); }

voidput_node(link_type p) { list_node_allocator::deallocate(p); }

link_type create_node(const T& x) {

link_type p = get_node();

__STL_TRY {

construct(&p->data, x);

}

__STL_UNWIND(put_node(p));

return p;

}

voiddestroy_node(link_type p) {

destroy(&p->data);

put_node(p);

}

list提供许多constrors，其中一个是defaultconstructors，允许我们不指定任何参数做出一个空的list出来：

public:

list(){ empty_initialize(); }

protected:

voidempty_initialize() {

node= get_node(); //配置一个节点空间，令node指向它

node->next = node; //令node头尾都指向自己，不设元素值

node->prev = node;

}

push_back()函数的实现：

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;

}

注意，插入节点完成后，新节点位于哨兵迭代器所指节点的前方。

list的元素操作

list的主要元素操作有push_front, push_back, erase, pop_front, pop_back, clear,remove, unique,splice,merge,reverse,sort。

这里主要分析下splice,merge,reverse,sort这四个操作。

list内部提供一个所谓的迁移操作(transfer)：将某连续范围内的元素迁移到某个特定位置之前。下面是transfer的源代码：

protected:

voidtransfer(iterator position, iterator first, iterator last) {

if(position != last) {

(*(link_type((*last.node).prev))).next = position.node;

(*(link_type((*first.node).prev))).next = last.node;

(*(link_type((*position.node).prev))).next = first.node;

link_type tmp = link_type((*position.node).prev);

(*position.node).prev = (*last.node).prev;

(*last.node).prev = (*first.node).prev;

(*first.node).prev = tmp;

}

}

下图展现transfer的实现：

上述的transfer并非公开接口。list公开提供的是所谓的接合操作(splice)：将某个连续范围的元素从一个list移动到另一个(或同一个)list的某个定点。下面是splice几个版本的实现：

public:

voidsplice(iterator position, list& x) {

if(!x.empty())

transfer(position, x.begin(), x.end());

}

voidsplice(iterator position, list&, iterator i) {

iterator j = i;

++j;

if(position == i || position == j) return;

transfer(position, i, j);

}

voidsplice(iterator position, list&, iterator first, iterator last) {

if(first != last)

transfer(position, first, last);

}

以下是merge(),reverse(), sort()的源代码：

//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();
  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()将*this的内容你想重置
template <class T, class Alloc>
void list<T, Alloc>::reverse() {
//以下判断，如果是空链表，或仅有一个元素，就不进行任何操作
  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);
  }
}   
//list不能使用STL算法sort(),必须使用自己的sort() memberfunction
//因为STL算法sort()只接受RamdonAccessIterator
//本函数采用quick sort
template <class T, class Alloc>
void list<T, Alloc>::sort() {
//以下判断，如果是空链表，或仅有一个元素，就不进行任何操作
  if(node->next == node || link_type(node->next)->next == node) return;
//一些新的lists,作为中介数据存放区
 list<T, Alloc> carry;
 list<T, Alloc> counter[64];
  intfill = 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]);
}