《Effective STL》學習筆記

http://www.cnblogs.com/arthurliu/archive/2011/08/07/2108386.html

作者：咆哮的馬甲 
出處：http://www.cnblogs.com/arthurliu/ 
本文版權歸作者和博客園共有，歡迎轉載，但未經作者同意必須保留此段聲明，且在文章頁面明顯位置給出原文連接。 
轉載請保持文檔的完整性，嚴禁用於任何商業用途，否則保留追究法律責任的權利。

第一條： 慎重選擇容器類型

C++所提供的容器類型有如下幾種：

• 標准STL序列容器 vector string deque list
• 標准STL關聯容器 set multiset map multimap
• 非標准序列容器 slist rope
• 非標准關聯容器 hash_set hash_multiset hash_map hash_multimap
• vector<char>作為string的替代
• vector作為標准關聯容器的替代
• 非標准的STL容器 array bitset valarray stack queue priority_queue

標准容器中的vector string和list比較熟悉。
deque是double ended queue,提供了與vector一樣的隨機訪問功能，但同時對頭尾元素的增刪操作提供了優化。
set和multiset中的數據都是順序排列的，數據值本身就是鍵值，set中的數據必須唯一而multiset沒有這樣的限制。
map和multimap中的數據對按照鍵值順序排列,map中不允許出現重復的key，而multimap中可以用相同的key對應不同的value。
slist是single linked list,與STL中標准的list之間的區別就在於slist的iterator是單向的，而list的iterator是雙向的。
rope用於處理大規模的字符串。
hash_set hash_multiset hash_map hash_multimap利用hash算法對相對應的關聯容器進行了優化。
bitset是專門用來存儲bit的容器。
valarray主要用於對一系列的數字進行高速運算。 
priority_queue類似於heap,可以高效的獲取最高priority的元素。

 

• 連續內存容器，動態申請一塊或多塊內存，每塊內存中存儲多個容器中的元素，當發生插入或刪除操作時，要對該內存中的其他元素進行新移動操作，這會降低效率。vector，string，rope都是連續內存容器。
• 基於節點的容器，為容器中的每一元素申請單獨的內存，元素中有指針指向其他的元素，插入和刪除的操作只需要改變指針的指向。缺點在於占用內存相對連續內存容器較大。list, slist, 關聯容器以及hash容器都是基於節點的容器。

如何選擇合適的STL容器

 

 

 

第二條： 不要編寫試圖獨立於容器的代碼
 

• 數組被泛化為以其所包含對象的類型為參數的容器
• 函數被泛化為以其使用的迭代器的類型為參數的算法
• 指針被泛化為以其所指向的對象的類型為參數的迭代器

考慮到以后可能會使用其他的容器替換現有的容器，為了使修改的部分最小化，最好采用如下的方式

 1 class Widget{...};
 2 template<typename T>
 3 SpecialAllocator{...};
 4 typedef vector<Widget, SpecialAllocator<Widget>> WidgetContainer;
 5 typedef WidgetContainer::iterator WCIterator;
 6 
 7 WidgetContainer wc;
 8 Widget widget;
 9 ...
10 WCIterator i = find(wc.begin(), wc.end(), widget);

 

使用Class將自定義的容器封裝起來，可以更好的實現修改部分最小化，同時達到了安全修改的目的

 1 class CustomizedContainer
 2 {
 3     private:
 4     
 5     typedef vector<Widget> InternalContainer;
 6     typedef InternalContainer::Iterator ICIterator;
 7     
 8     InternalContainer container;
 9     
10     public:
11     ...
12 };

　

　

第三條： 確保容器內對象的拷貝正確而高效

STL的工作方式是Copy In, Copy Out，也就是說在STL容器中的插入對象和讀取對象，使用的都是對象的拷貝。

在存放基類對象的容器中存放子類的對象，當容器內的對象發生拷貝時，會發生截斷(剝離 slicing)。

1 vector<Widget> vw;
2 
3 class SpecialWidget : public Widget
4 {
5 ...
6 };
7 
8 SpecialWidget sw;
9 vw.push_back(sw);

正確的方法是使容器包含指針而非對象。

1 vector<Widget*> vw;
2 
3 class SpecialWidget : public Widget
4 {
5 ...
6 };
7 
8 SpecialWidget sw;
9 vw.push_back(&sw);

　　

容器與數組在數據拷貝方面的對比：

當創建一個包含某類型對象的一個數組的時候，總是調用了次數等於數組長度的該類型的構造函數。盡管這個初始值之后會被覆蓋掉

Widget w[maxNumWidgets]; //maxNumWidgets 次的Widget構造函數

如果使用vecor，效率會有所提升。

vector<widget> w;     //既不調用構造函數也不調用拷貝構造函數

vector<widget> w(5);  //1次構造 5次拷貝構造

vector<widget> w;     //既不調用構造函數也不調用拷貝構造函數
w.reserve(5);         //既不調用構造函數也不調用拷貝構造函數

vector<widget> w(5);  //1次構造 5次拷貝構造
w.reserve(6);         //需要移動位置，調用5次拷貝構造

　

　

第四條： 調用empty()而不是檢查size()是否為0

empty()對於所有標准容器都是常數時間，而對list操作，size()耗費線性時間。

list具有常數時間的Splice操作，如果在兩個list之間做鏈接的時候需要記錄被鏈接到當前list的節點的個數，那么Splice操作將會變成線性時間。對於list而言，用戶對Splice效率的要求高於取得list長度的要求，所以list的size()需要耗費線性的時間去遍歷整個list。所以，調用empty()是判斷list是否為空的最高效方法。

 

第五條： 區間成員函數優先於與之對應的單元素成員函數

區間成員函數在效率方面的開銷要小於循環調用單元素的成員函數，以insert為例

1. 避免不必要的函數調用
2. 避免頻繁的元素移動
3. 避免多次進行內存分配

區間創建

1 container::container(InputIterator begin, InputIterator end);

區間插入

1 void container::insert(Iterator position, InputIterator begin, InputIterator end);
2 void associatedContainer::insert(InputIterator begin, InputIterator end);

區間刪除

1 Iterator container::erase(Iterator begin, Interator end);
2 void associatedContainer:erase(Iterator begin, Iterator end);

區間賦值

1 void container::assign(InputIterator begin, InputIterator end);

 

第六條：當心C++編譯器最煩人的分析機制

C++會盡可能的將一條語句解釋為函數聲明。

下列語句都聲明了一個函數返回值為int類型的函數f，其參數是double類型。

1 int f(double(d));
2 int f(double d);
3 int f(double); 　

下列語句都聲明了一個返回值為int類型的函數g，它的參數是返回值為double類型且無參的函數指針

1 int g(double(*pf)());
2 int g(double pf());
3 int g(double ()); //注意與int g(double (f))的區別

　　

對於如下語句，編譯器會做出這樣的解釋：聲明了一個返回值為list<int>的函數data，該函數有兩個參數，一個是istream_iterator<int>類型的變量，另一個是返回值為istream_iterator<int>類型的無參函數指針。

1 ifstream dataFile("ints.dat");
2 list<int> data(istream_iterator<int>(dataFile),istream_iterator<int>());

如果希望構造一個list<int>類型的變量data，最好的方式是使用命名的迭代器。盡管這與通常的STL風格相違背，但是消除了編譯器的二義性而且增強了程序的可讀性。

1 ifstream dataFile("ints.dat");
2 istream_iterator dataBegin(dataFile);
3 istream_iterator dataEnd;
4 list<int> data(dataBegin,dataEnd);　

第七條：如果容器中包含了通過new操作創建的指針，切記在容器對象析構前將指針delete掉

STL容器在析構之前，會將其所包含的對象進行析構。

 1 class widget
 2 {
 3     ...
 4 };
 5 
 6 doSth()
 7 {
 8     widget w; //一次構造函數
 9     vector<widget> v;
10     v.push_back(w); //一次拷貝構造函數
11 } // 兩次析構函數

但如果容器中包含的是指針的話，一旦沒有特別將指針delete掉將會發生內存泄漏

 1 class widget
 2 {
 3     ...
 4 };
 5 
 6 doSth()
 7 {
 8     widget* w = new widget();
 9     vector<widget*> v;
10     v.push_back(w); 
11 } // memory leak!!!

　　

最為方便並且能夠保證異常安全的做法是將容器所保存的對象定義為帶有引用計數的智能指針

 1 class widget
 2 {
 3     ...
 4 };
 5 
 6 doSth()
 7 {
 8     shared_ptr<widget> w(new widget()); //構造函數一次
 9     vector<shared_ptr<widget>> v;
10     v.push_back(w); 
11 } //析構函數一次 沒有內存泄漏

　

第八條：切勿創建包含auto_ptr對象的容器

由於auto_ptr對於其"裸指針"必須具有獨占性，當將一個auto_ptr的指針賦給另一個auto_ptr時，其值將被置空。

1 auto_ptr<int> p1(new int(1)); // p1 = 1
2 auto_ptr<int> p2(new int(2)); // p2 = 2
3 
4 p2 = p1; // p2 = 1  p1 = emtpy;

第三條提到STL容器中的插入對象和讀取對象，使用的都是對象的拷貝，並且基於STL容器的算法也通常需要進行對象的copy，所以，創建包含auto_ptr的容器是不明智的。


第九條：慎重選擇刪除元素的方法

要刪除容器中特定值的所有對象

1 //對於vector、string、deque 使用erase-remove方法
2 container.erase(remove(container.begin(),container.end(),value),container.end());
3 
4 //對於list 使用remove方法
5 list.remove(value);
6 
7 //對於標准關聯容器 使用erase方法
8 associatedContainer.erase(value);

要刪除容器中滿足特定條件的所有對象

 1 bool condition(int );
 2 
 3 //對於vector、string、deque 使用erase-remove_if方法
 4 container.erase(remove_if(container.begin(),container.end(),condition),container.end());
 5 
 6 //對於list 使用remove_if方法
 7 list.remove_if(condition);
 8 
 9 //對於標准關聯容器 第一種方法是結合remove_copy_if和swap方法
10 associatedContainer.remove_copy_if(associatedContainer.begin(),
11                                    associatedContainer.end(),
12                                    insert(tempAssocContainer,tempAssocContainer.end()),
13                                    condition);
14 
15 //另外一種方法是遍歷容器內容並在erase元素之前將迭代器進行后綴遞增
16 for(assocIt = associatedContainer.begin(); assocIt != associatedContainer.end())
17 {
18     if(condition(*assoIt))
19     {
20         ///當關聯容器中的一個元素被刪除掉時，所有指向該元素的迭代器都被設為無效，所以要提前將迭代器向后遞增
21         associatedContainer.erase(assoIt++); 
22     }
23     else
24     {
25         assocIt++;
26     }
27 }

如果出了在刪除容器內對象的同時還需要進行額外的操作時

 1 bool condition(int );
 2 void dosth();
 3 
 4 //對於標准序列容器，循環遍歷容器內容，利用erase的返回值更新迭代器
 5 for(containerIt = container.begin(); containerIt != container.end())
 6 {
 7     if(condition(*containerIt))
 8     {
 9         doSth();
10         //當標准容器中的一個元素被刪除掉時，所有指向該元素以及該元素之后的迭代器都被設為無效，所以要利用erase的返回值
11         containerIt = container.erase(containerIt++);
12     }
13     else
14     {
15         containerIt++;
16     }
17 }
18 
19 //對於標准關聯容器，循環遍歷容器內容，並在erase之前后綴遞增迭代器
20 for(assocIt = associatedContainer.begin(); assocIt != associatedContainer.end())
21 {
22     if(condition(*assoIt))
23     {
24         dosth();
25         associatedContainer.erase(assoIt++); 
26     }
27     else
28     {
29         assocIt++;
30     }
31 }

我覺得第三種情況下可以用第二種情況的實現代替，我們需要做的僅是將額外做的事情和判斷條件包裝在一個函數內，並用這個函數替代原有的判斷條件。　

 1 bool condition_doSth(int i)
 2 {
 3     bool ret = condition(i);
 4     if(ret)
 5     {
 6         doSth();
 7     }
 8 
 9     return ret;
10 }

第十條：了解分配子的約定和限制

如果需要編寫自定義的分配子，有以下幾點需要注意

• 當分配子是一個模板，模板參數T代表你為其分配內存的對象的類型
• 提供類型定義pointer和reference，始終讓pointer為T*而reference為T&
• 不要讓分配子擁有隨對象而不同的狀態，通常，分配子不應該有非靜態數據成員
• 傳遞給allocator的是要創建元素的個數而不是申請的字節數，該函數返回T*，盡管此時還沒有T對象構造出來
• 必須提供rebind模板，因為標准容器依賴於該模板

第十一條：理解自定義分配子的合理用法

如果需要在共享的內存空間中手動的管理內存分配，下列代碼提供了一定的參考

 1 //用戶自定義的管理共享內存的malloc和free
 2 void* mallocShared(size_t bytesNeeded);
 3 void* freeShared(void* ptr);
 4 
 5 template<typename T>
 6 class sharedMemoryAllocator
 7 {
 8 public:
 9     ...
10     
11     point allocator(size_type numObjects, const void* localityHint=0)
12     {
13         return static_cast<pointer>(mallocShared(numObjects*sizeof(T)));
14     }
15 
16     void deallocate(pointer ptrMemory, size_type numObjects)
17     {
18         freeShared(ptrMemory);
19     }
20 
21     ...
22 }

　　
如果不僅僅是將容器的元素放在共享內存，而且要將容器對象本身也放在共享內存中，參考如下代碼

1 void* ptrVecMemory = mallocShared(sizeof(SharedDoubleVec));
2 SharedDoubleVec* sharedVec = new(ptrVecMemory) SharedDoubleVec;
3 
4 ...
5 
6 sharedVec->~SharedDoubleVec();
7 freeShared(sharedVec);

第十二條：切勿對STL容器的線程安全性有不切實際的依賴

• 對於STL容器的多線程讀是安全的
• 對於多個不同的STL容器

采用面向對象的方式對STL容器進行加鎖和解鎖

 1 template<typename Container>
 2 class lock
 3 {
 4 public:
 5 
 6     Lock(const Container& container):c(container)
 7     {
 8         getMutexFor(c);
 9     }
10 
11     ~Lock()
12     {
13         releaseMutex(c);
14     }
15 
16 private:
17 
18     Container& c;
19 },
20 
21 
22
23 vector<int> v;
24 ...
25 
26 {
27     Lock<vector<int>> lock(v); //構造lock,加鎖v
28     doSthSync(v); //對v進行多線程的操作
29 } //析構lock,解鎖v