1、Terms14:Think carefully about copying behavior in resource-managing classes

條款13，引入了RAII原則，以此作為資源管理的一個原則。對于heap_based的資源，用auto_ptr，tr1::shared_ptr比較合適。但是對于非heap_based的資源，可能需要建立自己的資源管理類。
舉一個栗子：

 #include <iostream>using namespace std;class Lock
{
public:explicit Lock(int* pm): m_p(pm){lock(m_p);}~Lock(){unlock(m_p);}private:int *m_p;void lock(int* pm){cout << "Address = " << pm << " is locked" << endl;}void unlock(int *pm){cout << "Address = " << pm << " is unlocked" << endl;}
};int main()
{int m = 5;Lock m1(&m);
}

這個是模仿原書中的例子，做的一個加鎖和解鎖的操作。
運行結果如下：

Address = 0x7ffc0820f6bc is locked
Address = 0x7ffc0820f6bc is unlocked...Program finished with exit code 0
Press ENTER to exit console.

這符合預期，當m1獲得資源的時候，將之鎖住，而m1生命周期結束后，也將資源的鎖釋放。
注意到Lock類中有一個指針成員，那么如果使用默認的析構函數、拷貝構造函數和賦值運算符，很可能會有嚴重的bug。
我們不妨在main函數中添加一句話，變成下面這樣：

 int main()
{int m = 5;     Lock m1(&m);Lock m2(m1);
}

再次運行，可以看到結果：

Address = 0x7fffa98a14d4 is locked
Address = 0x7fffa98a14d4 is unlocked
Address = 0x7fffa98a14d4 is unlocked...Program finished with exit code 0
Press ENTER to exit console.

可見，鎖被釋放了兩次，這就出問題了。原因是析構函數被調用了兩次，在main()函數中生成了兩個Lock對象，分別是m1和m2，Lock m2(m1)這句話使得m2.m_p = m1.m_p，這樣這兩個指針就指向了同一塊資源。根據后生成的對象先析構的原則，所以m2先被析構，調用他的析構函數，釋放資源鎖，但釋放的消息并沒有通知到m1，所以m1在隨后析構函數中，也會釋放資源鎖。
如果這里的釋放不是簡單的一句輸出，而是真的對內存進行操作的話，程序就會崩潰。
歸根到底，是程序使用了默認了拷貝構造函數造成的（當然，如果使用賦值運算的話，也會出現相同的bug），那么解決方案就是圍繞如何正確擺平這個拷貝構造函數（和賦值運算符）。

方法一：禁止復制

很簡單直觀，就是干脆不讓程序員使用類似于Lock m2(m1)這樣的語句，一用就報編譯錯。這可以通過自己寫一個私有的拷貝構造函數和賦值運算符的聲明來解決。注意這里只要寫聲明就行了。
舉個例子：

class Lock
{public:explicit Lock(int* pm): m_p(pm){lock(m_p);}~Lock(){unlock(m_p);}private:int *m_p;void lock(int* pm){cout << "Address = " << pm << " is locked" << endl;}void unlock(int *pm){cout << "Address = " << pm << " is unlocked" << endl;}private:Lock(const Lock&);Lock& operator= (const Lock&);
};

方法二：對底層資源使出“引用計數法”

就是使用shared_ptr來進行資源管理（見條款13），但還有一個問題，我想在生命周期結束后調用Unlock的方法，其實shared_ptr里面的刪除器可以幫到我們。
舉個栗子：

class Lock{public:explicit Lock(int *pm): m_p(pm, unlock){…}private:shared_ptr<int> m_p;}

這樣在Lock的對象的生命周期結束后，就可以自動調用unlock了。
在條款十三的基礎上，我改了一下自定義的shared_ptr，使之也支持刪除器的操作了，
完整代碼如下：

#ifndef MY_SHARED_PTR_H
#define MY_SHARED_PTR_H#include <iostream>
using namespace std;typedef void (*FP)();    template <class T>
class MySharedPtr
{private:T *ptr;size_t *count;FP Del; // 聲明一個刪除器static void swap(MySharedPtr& obj1, MySharedPtr& obj2){std::swap(obj1.ptr, obj2.ptr);std::swap(obj1.count, obj2.count);std::swap(obj1.Del, obj2.Del);}public:MySharedPtr(T* p = NULL): ptr(p), count(new size_t(1)),Del(NULL){}// 添加帶刪除器的構造函數MySharedPtr(T* p, FP fun): ptr(p), count(new size_t(1)), Del(fun){}MySharedPtr(MySharedPtr& p): ptr(p.ptr), count(p.count), Del(p.Del){++ *p.count;}MySharedPtr& operator= (MySharedPtr& p){if(this != &p && (*this).ptr != p.ptr){MySharedPtr temp(p);swap(*this, temp);}return *this;}~MySharedPtr(){if(Del != NULL){Del();}    reset();}T& operator* () const{return *ptr;}T* operator-> () const {return ptr;}T* get() const {return ptr;}void reset(){-- *count;if(*count == 0){delete ptr;ptr = 0;delete count;count = 0;//cout << "真正刪除" << endl;}}bool unique() const{return *count == 1;}size_t use_count() const {return *count;}friend ostream& operator<< (ostream& out, const MySharedPtr<T>& obj){out << *obj.ptr;return out;}};#endif /* MY_SHARED_PTR_H */

方法三：復制底部資源

就是將原來的淺拷貝轉換成深拷貝，需要自己顯示定義拷貝構造函數和賦值運算符。這個也在之前的條款說過了，放到這里，其實就是在拷貝的時候對鎖的計數次數進行+1，析構函數里就是對鎖的計數次數進行-1，如果減到0就去unlock（其實思想還是類似于shared_ptr進行資源管理）

方法四：轉移底部資源的擁有權

轉移底部資源的控制權，這就是auto_ptr干的活了，在第二個方法中把shared_ptr換成auto_ptr就行了。

2、總結

天堂有路你不走，地獄無門你自來。

3、參考

3.1 《Effective C++》
3.2 讀書筆記_Effective_C++_條款十四：在資源管理類中小心copying行為