2. 程式人生 > >STL原始碼分析之slist有序容器 上

STL原始碼分析之slist有序容器 上

阿新 • • 發佈：2018-12-08

前言

不同於list是Forward Iterator型別的雙向連結串列, slist是單向連結串列, 也是Bidirectional Iterator型別. slist主要耗費的空間小, 操作一些特定的操作更加的快, 同樣類似與slist, 在執行插入和刪除操作迭代器都不會像vector使迭代器失效. slist主要的問題在於它是單向的, 正向迭代器, 只有push_front, 沒有push_back的操作, 指定位置之後的插入和刪除時間都是O(1), 而在指定位置之前插入就需要重新遍歷連結串列時間就是O(n), 效率很低.

slist原始碼

slist的構成與list

還是異曲同工.

節點結構

將節點的每一部分都進行剝離, 節點是一個結構構成, 資料是繼承節點.

struct __slist_node_base
{
  __slist_node_base* next;	// 只有指向下一個節點的指標
};
// 繼承節點指標, __slist_node增加資料
template <class T>
struct __slist_node : public __slist_node_base
{
  T data;
};

節點的操作

在節點指定節點後插入新的節點.

inline __slist_node_base* __slist_make_link
 
(__slist_node_base* prev_node, __slist_node_base* new_node)
{
  new_node->next = prev_node->next;
  prev_node->next = new_node;
  return new_node;
}

尋找指定節點的prev節點. 因為slist是正向迭代器就只有遍歷連結串列

inline __slist_node_base* __slist_previous(__slist_node_base* head, const __slist_node_base* node)
{
 

    // 遍歷整個連結串列來尋找
  while (head && head->next != node)
    head = head->next;
  return head;
}
inline const __slist_node_base* __slist_previous(const __slist_node_base* head,const __slist_node_base* node)
{
    // 遍歷整個連結串列來尋找
  while (head && head->next != node)
    head = head->next;
  return head;
}

將指定範圍的連結串列剪下到pos連結串列後

inline void __slist_splice_after(__slist_node_base* pos,__slist_node_base* before_first, __slist_node_base* before_last)
{
  if (pos != before_first && pos != before_last) {
    __slist_node_base* first = before_first->next;
    __slist_node_base* after = pos->next;
      // 將before_first之後的調整為before_last後面的連結串列
    before_first->next = before_last->next;
      // 將[before_first->next, before_last]插入到pos之後
    pos->next = first;
    before_last->next = after;
  }
}

將連結串列進行倒轉

inline __slist_node_base* __slist_reverse(__slist_node_base* node)
{
  __slist_node_base* result = node;
  node = node->next;
  result->next = 0;
  while(node) {
      // 將原連結串列一一的插入到臨時連結串列的尾, 實現連結串列的元素倒轉
    __slist_node_base* next = node->next;
    node->next = result;
    result = node;
    node = next;
  }
  return result;
}

迭代器

之前說過slist的迭代器是正向的, 現在就來具體分析.

__slist_iterator_base單向連結串列的迭代器基本結構

struct __slist_iterator_base
{
    // 定義型別
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef forward_iterator_tag iterator_category;
	// 定義節點指標
  __slist_node_base* node;
	// 建構函式
  __slist_iterator_base(__slist_node_base* x) : node(x) {}
    // incr: 只正向.
  void incr() { node = node->next; }
	// 只過載了==,!=
  bool operator==(const __slist_iterator_base& x) const {
    return node == x.node;
  }
  bool operator!=(const __slist_iterator_base& x) const {
    return node != x.node;
  }
};

__slist_iterator單向連結串列迭代器結構. 只過載實現了++操作, 沒有–, 因為就只是正向迭代, --操作就需要重新遍歷連結串列.

template <class T, class Ref, class Ptr>
struct __slist_iterator : public __slist_iterator_base
{
	// 定義迭代器
  typedef __slist_iterator<T, T&, T*>             iterator;
  typedef __slist_iterator<T, const T&, const T*> const_iterator;
  typedef __slist_iterator<T, Ref, Ptr>           self;
	// 滿足traits程式設計
  typedef T value_type;
  typedef Ptr pointer;
  typedef Ref reference;
  	// 定義連結串列節點
  typedef __slist_node<T> list_node;
	// 建構函式
  __slist_iterator(list_node* x) : __slist_iterator_base(x) {}
  __slist_iterator() : __slist_iterator_base(0) {}
  __slist_iterator(const iterator& x) : __slist_iterator_base(x.node) {}
	// 獲得當前指標的值
  reference operator*() const { return ((list_node*) node)->data; }
#ifndef __SGI_STL_NO_ARROW_OPERATOR
  pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */

	// 對++過載
  self& operator++()
  {
    incr(); // 指向下一個節點
    return *this;
  }
  self operator++(int)
  {
    self tmp = *this;
    incr();
    return tmp;
  }
};

#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
inline ptrdiff_t* distance_type(const __slist_iterator_base&)
{
  return 0;
}
inline forward_iterator_tag iterator_category(const __slist_iterator_base&)
{
  return forward_iterator_tag();
}
template <class T, class Ref, class Ptr> 
inline T*  value_type(const __slist_iterator<T, Ref, Ptr>&) {
  return 0;
}
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

通過遍歷整個連結串列計算連結串列的長度.

inline size_t __slist_size(__slist_node_base* node)
{
  size_t result = 0;
  for ( ; node != 0; node = node->next)
    ++result;
  return result;
}

slist分析

slist型別定義.

template <class T, class Alloc = alloc>
class slist
{
public:
    // 滿足traits程式設計
  typedef T value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
	
    // 定義迭代器
  typedef __slist_iterator<T, T&, T*>             iterator;
  typedef __slist_iterator<T, const T&, const T*> const_iterator;

private:
  typedef __slist_node<T> list_node;	// 定義連結串列
  typedef __slist_node_base list_node_base;	// 定義節點
  typedef __slist_iterator_base iterator_base;	// 單向連結串列迭代器的基本結構定義
  typedef simple_alloc<list_node, Alloc> list_node_allocator;	// 定義空間配置器

private:
  list_node_base head;	// 定義節點的頭
    ...	
};
slist建構函式
template <class T, class Alloc = alloc>
class slist
{
	...
public:
  slist() { head.next = 0; }	// 預設建構函式, head.next == 0

    // 以下建構函式都呼叫fill_initialize填充連結串列
  slist(size_type n, const value_type& x) { fill_initialize(n, x); }
  slist(int n, const value_type& x) { fill_initialize(n, x); }
  slist(long n, const value_type& x) { fill_initialize(n, x); }
  explicit slist(size_type n) { fill_initialize(n, value_type()); }	// 不能隱式呼叫該建構函式

#ifdef __STL_MEMBER_TEMPLATES
    // 接受兩個迭代器, 範圍初始化
  template <class InputIterator>
  slist(InputIterator first, InputIterator last) {
    range_initialize(first, last);
  }
#else /* __STL_MEMBER_TEMPLATES */
  slist(const_iterator first, const_iterator last) {
    range_initialize(first, last);
  }
  slist(const value_type* first, const value_type* last) {
    range_initialize(first, last);
  }
#endif /* __STL_MEMBER_TEMPLATES */
	...
};

fill_initialize, 初始化

void fill_initialize(size_type n, const value_type& x) {
    head.next = 0;
    __STL_TRY {
      _insert_after_fill(&head, n, x);
    }
    __STL_UNWIND(clear());
}

range_initialize, 自定義範圍初始化

template <class T, class Alloc = alloc>
class slist
{
	...
private:
#ifdef __STL_MEMBER_TEMPLATES
  template <class InputIterator>
  void range_initialize(InputIterator first, InputIterator last) {
    head.next = 0;
    __STL_TRY {
      _insert_after_range(&head, first, last);
    }
    __STL_UNWIND(clear());
  }
#else /* __STL_MEMBER_TEMPLATES */
  void range_initialize(const value_type* first, const value_type* last) {
    head.next = 0;
    __STL_TRY {
      _insert_after_range(&head, first, last);
    }
    __STL_UNWIND(clear());
  }
  void range_initialize(const_iterator first, const_iterator last) {
    head.next = 0;
    __STL_TRY {
      _insert_after_range(&head, first, last);
    }
    __STL_UNWIND(clear());
  }
#endif /* __STL_MEMBER_TEMPLATES */
	...
};

range_initialize和fill_initialize函式都是呼叫_insert_after_range, _insert_after_range也是有多個過載函式.

_insert_after_range, 初始化成員屬性

template <class T, class Alloc = alloc>
class slist
{
	...
private:
  void _insert_after_fill(list_node_base* pos,
                          size_type n, const value_type& x) {
      // 構造出n個節點並初始化為x
    for (size_type i = 0; i < n; ++i)
      pos = __slist_make_link(pos, create_node(x));
  }

#ifdef __STL_MEMBER_TEMPLATES
  template <class InIter>
  void _insert_after_range(list_node_base* pos, InIter first, InIter last) {
      // 構造出 [first, last) 個節點並初始化為first
    while (first != last) {
      pos = __slist_make_link(pos, create_node(*first));
      ++first;
    }
  }
#else /* __STL_MEMBER_TEMPLATES */
  void _insert_after_range(list_node_base* pos,
                           const_iterator first, const_iterator last) {
      // 構造出 [first, last) 個節點並初始化為first
    while (first != last) {
      pos = __slist_make_link(pos, create_node(*first));
      ++first;
    }
  }
  void _insert_after_range(list_node_base* pos,
                           const value_type* first, const value_type* last) {
      // 構造出 [first, last) 個節點並初始化為first
    while (first != last) {
      pos = __slist_make_link(pos, create_node(*first));
      ++first;
    }
  }
#endif /* __STL_MEMBER_TEMPLATES */
    ...
};

create_node函式, 呼叫空間配置器分配空間然後在呼叫建構函式

template <class T, class Alloc = alloc>
class slist
{
	...
private:
  static list_node* create_node(const value_type& x) {
      // 空間配置器分配空間
    list_node* node = list_node_allocator::allocate();
    __STL_TRY {
        // 呼叫建構函式
      construct(&node->data, x);
      node->next = 0;
    }
      // 如果分配失敗就釋放掉之前分配的所有空間
    __STL_UNWIND(list_node_allocator::deallocate(node));
    return node;
  }
	...
};
解構函式
template <class T, class Alloc = alloc>
class slist
{
	...
private:
    ~slist() { clear(); }	// 呼叫clear函式將所有元素進行刪除和釋放
    ...
};

destroy_node函式, 呼叫解構函式之後再釋放空間

template <class T, class Alloc = alloc>
class slist
{
	...
private:
  static void destroy_node(list_node* node) {
    destroy(&node->data);	// 呼叫解構函式
    list_node_allocator::deallocate(node);	// 釋放記憶體空間
  }
	...
};
拷貝建構函式
template <class T, class Alloc = alloc>
class slist
{
	...
private:
    // 直接呼叫range_initialize函式進行初始化
  slist(const slist& L) { range_initialize(L.begin(), L.end()); }
    ...
};

總結

本節只是對slist的基本構成, 建構函式和解構函式做了一個探討, 下一節就準備分析slist的刪除, 插入等具體操作的實現.

相關推薦

STL原始碼分析之slist有序容器 上

前言 不同於list是Forward Iterator型別的雙向連結串列, slist是單向連結串列, 也是Bidirectional Iterator型別. slist主要耗費的空間小, 操作一些特定的操作更加的快, 同樣類似與slist, 在執行插入和刪除操作迭代器都不會像vec

STL原始碼分析之slist有序容器 下

前言 上節我們對slist的基本構成, 構造析構做了分析, 本節 我們就來分析關於slist的基本元素操作. slist分析 基本屬性資訊 slist是隻有正向迭代, 所以只能直接獲取頭部的資料. template <class T, class Alloc =

STL原始碼分析之deque有序容器 上

前言 deque的功能很強大, 其複雜度也比list, vector複雜很多. deque是一個random_access_iterator_tag型別. 前面分析過vector是儲存在連續的線性空間, 頭插入和刪除其代價都很大, 當陣列滿了還要重新尋找更大的空間; deque也是一

STL原始碼分析之hashtable關聯容器 上

前言 前面我們分析過RB-tree關聯容器, RB-tree在插入(可重複和不可重複), 刪除等操作時間複雜度都是O(nlngn), 以及滿足5個規則, 以及以他為底層的配接器; 本節就來分析hashtable另個關聯容器, 他在插入, 刪除等操作都可以做到O(1)的時間複雜度.

STL原始碼分析之deque有序容器 中

前言 前一節我們分析了deque的基本使用, 本節我們來分析一下deque的對map的操作, 即插入, 刪除等. 但是本節只分析push, pop和刪除操作, 而insert操作有點複雜還是放到下節來分析. push, pop 因為deque的是能夠雙向操作, 所以其push

STL原始碼分析之list有序容器 下

前言 前兩節對list的push, pop, insert等操作做了分析, 本節準備探討list怎麼實現sort功能. list是一個迴圈雙向連結串列, 不是一個連續地址空間, 所以sort功能需要特殊的演算法單獨實現, 而不能用演算法中的sort. 當然還可以將list的元素插

STL原始碼分析之RB-tree關聯容器 上

前言 本節將分析STL中難度很高的RB-tree, 如果對紅黑樹有所認識的那麼分析起來的難度也就不是很大, 對紅黑樹沒有太多瞭解的直接來分析的難度就非常的大了, 可以對紅黑樹有個瞭解紅黑樹之原理和演算法詳細介紹. 紅黑樹是很類似與AVL-tree的, 但是因為AVL-tree在插入,

Spark原始碼分析之Spark Shell（上）

https://www.cnblogs.com/xing901022/p/6412619.html 文中分析的spark版本為apache的spark-2.1.0-bin-hadoop2.7。 bin目錄結構： -rwxr-xr-x. 1 bigdata bigdata 1089 Dec

STL原始碼分析之__type_traits型別

前言 上一篇探討的是traits是為了將迭代器沒能完善的原生指標, traits用特化和偏特化程式設計來完善. 這一篇準備探討__type_traits, 為了將我們在空間配置器裡面的提過的__true_type和false_type進行解答. 而type_traits型別對我們ST

STL原始碼分析之traits萃取劑

前言 前面我們分析了迭代器的五類, 而迭代器所指向物件的型別被稱為value type. 傳入引數的型別可以通過編譯器自行推斷出來, 但是如果是函式的返回值的話, 就無法通過value type讓編譯器自行推斷出來了. 而traits就解決了函式返回值型別. 同樣原生指標不能內嵌型別

STL原始碼分析之迭代器

前言 迭代器是將演算法和容器兩個獨立的泛型進行調和的一個介面. 使我們不需要關係中間的轉化是怎麼樣的就都能直接使用迭代器進行資料訪問. 而迭代器最重要的就是對operator *和operator->進行過載, 使它表現的像一個指標. 型別 迭代器根據移動特性和實施操作

STL原始碼分析之記憶體池

前言 上一節只分析了第二級配置器是由多個連結串列來存放相同記憶體大小, 當沒有空間的時候就向記憶體池索取就行了, 卻沒有具體分析記憶體池是怎麼儲存空間的, 是不是記憶體池真的有用不完的記憶體, 本節我們就具體來分析一下 記憶體池 static data template的初始

STL原始碼分析之第二級配置器

前言 第一級是直接呼叫malloc分配空間, 呼叫free釋放空間, 第二級三就是建立一個記憶體池, 小於128位元組的申請都直接在記憶體池申請, 不直接呼叫malloc和free. 本節分析第二級空間配置器, STL將第二級配置器設定為預設的配置器, 所以只要一次申請的空間不超過1

STL原始碼分析之第一級配置器

前言 上一節我們分析了空間配置器對new的配置, 而STL將空間配置器分為了兩級, 第一級是直接呼叫malloc分配空間, 呼叫free釋放空間, 第二級三就是建立一個記憶體池, 小於128位元組的申請都直接在記憶體池申請, 不直接呼叫malloc和free. 本節我們就先分析第

STL原始碼分析之空間配置器

前言 SGI STL將new的申請空間和呼叫建構函式的兩個功能分開實現, 如果對new不太清楚的, 可以先去看看這一篇new實現再來看配置器也不遲. 本節是STL分析的第一篇, 主要分析STL各個部分都會出現的alloc實現, 雖然每個部分都只會預設呼叫它, 不瞭解它也可以看懂分析,

STL原始碼分析之deque 下

前言 前面兩節對deque基本所有的操作都分析了, 本節就分析deque的insert操作的實現. insert的過載函式有很多, 所以沒有在上節一起分析, 本節也只是對部分過載函式進行分析, 剩下的列出原始碼就行了. 原始碼分析 insert實現 這裡先將insert的

STL原始碼分析之multimap配接器

前言 前面我們分析了map, 知道map是不允許插入相同的鍵值的, 也不會儲存第二次的資料, 而本節分析的multimap與map不同, 它允許多個重複的鍵值插入. mutimap操作 int main() { multimap<string, int> mul

STL原始碼分析之multiset配接器

前言 前面也分析過set, 並且set不能插入相同的鍵, 本節分析的multiset與set不同之處就是他允許插入相同的鍵. multiset操作 int main() { multiset<string> multi; // 允許重複插入鍵 mult

STL原始碼分析之map配接器

前言 上一節分析了pair結構, 正是為map分析做鋪墊, map本身實現也不難, 其資料儲存是pair, 儲存結構是RB-tree, 即map也並不能說是關聯容器, 而應該是配接器. map操作 map的insert必須是以pair為儲存結構, 當然也可以直接使用make_

STL原始碼分析之pair結構體

前言 前面在分析set, RB-tree都有在insert實現中出現pair, 下節分析map的時候更會經常出現pair, 所以打算在之前先對pair有個認識. pair是一個有兩個變數的結構體, 即誰都可以直接呼叫它的變數, 畢竟struct預設許可權都是public, 將兩個