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```節點作用是非常大的，就這一個節點就能表示除一個完整的雙向迴圈連結串列。