SGISTL源码阅读十二 list容器中

SGISTL源码阅读十二 list容器中

前言

在list容器上中我们介绍了list的数据结构，构造，空间分配等。接下来我们继续分析list的一些相关操作。

深入源码

begin()/end

//返回头节点
iterator begin() { return (link_type)((*node).next); }
const_iterator begin() const { return (link_type)((*node).next); }
//返回尾节点
iterator end() { return node; }
const_iterator end() const { return node; }

front()/back()

//返回list的第一个元素
reference front() { return *begin(); }
const_reference front() const { return *begin(); }
//返回list的最后一个元素（node节点是不存放元素的）
reference back() { return *(--end()); }
const_reference back() const { return *(--end()); }

empty()/clear()

//判断node节点的next指向是否它本身
 bool empty() const { return node->next == node; }

template <class T, class Alloc>
void list<T, Alloc>::clear()
{
  //销毁除node之外的所有节点
  link_type cur = (link_type) node->next;
  while (cur != node) {
    link_type tmp = cur;
    cur = (link_type) cur->next;
    destroy_node(tmp);
  }
  //讲node的prev和next分别指向它自己
  node->next = node;
  node->prev = node;
}

size()/resize()

size_type size() const {
    size_type result = 0;
    //调用distance
    distance(begin(), end(), result);
    return result;
}

template <class T, class Alloc>
void list<T, Alloc>::resize(size_type new_size, const T& x)
{
  iterator i = begin();
  size_type len = 0;
  //没有循环体的for循环
  //用于判断new_size是否比当前list的长度长，并用i迭代器标记位置
  for ( ; i != end() && len < new_size; ++i, ++len);
  //如果new_size小于等于当前list长度，将list多余元素清除
  if (len == new_size)
    erase(i, end());
  //否则插入值为x的元素，个数为new_size-len
  else                          // i == end()
    insert(end(), new_size - len, x);
}

insert

insert操作分为以下几种

指定位置前插入一个元素
指定位置前迭代器范围插入
指定位置前插入n个值为x的元素

• 指定位置前插入一个元素

  //在positon前插入值为x的节点
  iterator insert(iterator position, const T& x) {
    //申请并初始化一个节点
    link_type tmp = create_node(x);
    //维护它的内部指向
    tmp->next = position.node;
    tmp->prev = position.node->prev;
    (link_type(position.node->prev))->next = tmp;
    position.node->prev = tmp;
    //返回指向新插入节点的迭代器
    return tmp;
  }
  //插入一个默认值节点，调用了前面的insert
  iterator insert(iterator position) { return insert(position, T()); }

• 指定位置前迭代器范围插入

//以下为指定位置前迭代器范围插入函数的声明
template <class InputIterator>
void insert(iterator position, InputIterator first, InputIterator last);
void insert(iterator position, const T* first, const T* last);
void insert(iterator position,
          const_iterator first, const_iterator last);
//...
template <class T, class Alloc> template <class InputIterator>
void list<T, Alloc>::insert(iterator position,
                            InputIterator first, InputIterator last) {
   /* 利用insert向前插入的特性
    * 每次都朝position插入
    */
  for ( ; first != last; ++first)
    insert(position, *first);
}
//重载版本
template <class T, class Alloc>
void list<T, Alloc>::insert(iterator position, const T* first, const T* last) {
  for ( ; first != last; ++first)
    insert(position, *first);
}
//重载版本
template <class T, class Alloc>
void list<T, Alloc>::insert(iterator position,
                            const_iterator first, const_iterator last) {
  for ( ; first != last; ++first)
    insert(position, *first);
}

• 指定位置前插入n个值为x的元素

//指定位置前插入n个值为x的元素函数声明
void insert(iterator pos, size_type n, const T& x);
void insert(iterator pos, int n, const T& x) {
insert(pos, (size_type)n, x);
}
void insert(iterator pos, long n, const T& x) {
insert(pos, (size_type)n, x);
}
//...
template <class T, class Alloc>
void list<T, Alloc>::insert(iterator position, size_type n, const T& x) {
    /* 由于insert的特性在position指定的位置前面插入
     * 所以调用n次insert就行了
     */
  for ( ; n > 0; --n)
    insert(position, x);
}

transfer

该函数的作用是将[first, last)范围内的元素移动到position前。代码看起来可能有些复杂，但是这个函数相当重要，后面会有函数调用它。我们通过图示来说明。

  void transfer(iterator position, iterator first, iterator last) {
    //判断position和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;
    }
  }

不得不说，这样看起来是真的很乱，我们整合一下(因为是前闭后开区间，所以是不包含last节点的)

splice

splice的作用是拼接，它根据不同的情况重载了不同的版本，调用了transfer

void splice(iterator position, list& x) {
    if (!x.empty())
      //调用transfer将x移动到position前
      transfer(position, x.begin(), x.end());
  }
  void splice(iterator position, list&, iterator i) {
    iterator j = i;
    ++j;
    //若position和i指向的元素相同或者i指向的元素本来就在position前面,直接return
    if (position == i || position == j) return;
    //否则将[i, j)移动到position前
    transfer(position, i, j);
  }
  //该函数的作用是将[first, last)范围内的元素拼接到position前
  void splice(iterator position, list&, iterator first, iterator last) {
    if (first != last)
      transfer(position, first, last);
  }

总结

我们学习了list的一些常用操作，其中比较复杂的是transfer函数。
通过以上源码的学习，我们可以看到list``中的node```节点作用是非常大的，就这一个节点就能表示除一个完整的双向循环链表。