【C++】智慧指標
前言
C++裡面的四個智慧指標: auto_ptr, unique_ptr,shared_ptr, weak_ptr 其中後三個是C++11支援，並且第一個已經被C++11棄用。
C++11智慧指標介紹
智慧指標主要用於管理在堆上分配的記憶體，它將普通的指標封裝為一個棧物件。當棧物件的生存週期結束後，會在解構函式中釋放掉申請的記憶體，從而防止記憶體洩漏。C++ 11中最常用的智慧指標型別為shared_ptr,它採用引用計數的方法，記錄當前記憶體資源被多少個智慧指標引用。該引用計數的記憶體在堆上分配。當新增一個時引用計數加1，當過期時引用計數減一。只有引用計數為0時，智慧指標才會自動釋放引用的記憶體資源。對shared_ptr進行初始化時不能將一個普通指標直接賦值給智慧指標，因為一個是指標，一個是類。可以通過make_shared函式或者通過建構函式傳入普通指標。並可以通過get函式獲得普通指標。
為什麼要使用智慧指標
智慧指標的作用是管理一個指標，因為存在以下這種情況：申請的空間在函式結束時忘記釋放，造成記憶體洩漏。使用智慧指標可以很大程度上的避免這個問題，因為智慧指標是一個類，當超出了類的例項物件的作用域時，會自動呼叫物件的解構函式，解構函式會自動釋放資源。所以智慧指標的作用原理就是在函式結束時自動釋放記憶體空間，不需要手動釋放記憶體空間。
auto_ptr
（C++98的方案，C++11已經拋棄）採用所有權模式。
cppauto_ptr<string> p1 (new string ("I reigned lonely as a cloud."));
auto_ptr<string> p2;
p2 = p1; //auto_ptr不會報錯.
此時不會報錯，p2剝奪了p1的所有權，但是當程式執行時訪問p1將會報錯。所以auto_ptr的缺點是：存在潛在的記憶體崩潰問題！
unique_ptr
（替換auto_ptr）unique_ptr實現獨佔式擁有或嚴格擁有概念，保證同一時間內只有一個智慧指標可以指向該物件。它對於避免資源洩露(例如“以new建立物件後因為發生異常而忘記呼叫delete”)特別有用。
採用所有權模式，還是上面那個例子
cppunique_ptr<string> p3 (new string ("auto")); //#4
unique_ptr<string> p4； //#5
p4 = p3;//此時會報錯！！
編譯器認為p4=p3非法，避免了p3不再指向有效資料的問題。嘗試複製p3時會編譯期出錯，而auto_ptr能通過編譯期從而在執行期埋下出錯的隱患。因此，unique_ptr比auto_ptr更安全。
另外unique_ptr還有更聰明的地方：當程式試圖將一個 unique_ptr 賦值給另一個時，如果源 unique_ptr 是個臨時右值，編譯器允許這麼做；如果源 unique_ptr 將存在一段時間，編譯器將禁止這麼做，比如：
cppunique_ptr<string> pu1(new string ("hello world"));
unique_ptr<string> pu2;
pu2 = pu1; // #1 不允許
unique_ptr<string> pu3;
pu3 = unique_ptr<string>(new string ("You")); // #2 允許
其中#1留下懸掛的unique_ptr(pu1)，這可能導致危害。而#2不會留下懸掛的unique_ptr，因為它呼叫 unique_ptr 的建構函式，該建構函式建立的臨時物件在其所有權讓給 pu3 後就會被銷燬。這種隨情況而已的行為表明，unique_ptr 優於允許兩種賦值的auto_ptr 。
注：如果確實想執行類似與#1的操作，要安全的重用這種指標，可給它賦新值。C++有一個標準庫函式std::move()，讓你能夠將一個unique_ptr賦給另一個。儘管轉移所有權後 還是有可能出現原有指標呼叫（呼叫就崩潰）的情況。但是這個語法能強調你是在轉移所有權，讓你清晰的知道自己在做什麼，從而不亂呼叫原有指標。
（額外：boost庫的boost::scoped_ptr也是一個獨佔性智慧指標，但是它不允許轉移所有權，從始而終都只對一個資源負責，它更安全謹慎，但是應用的範圍也更狹窄。）
例如：
cppunique_ptr<string> ps1, ps2;
ps1 = demo("hello");
ps2 = move(ps1);
ps1 = demo("alexia");
cout << *ps2 << *ps1 << endl;
shared_ptr
shared_ptr實現共享式擁有概念。多個智慧指標可以指向相同物件，該物件和其相關資源會在“最後一個引用被銷燬”時候釋放。從名字share就可以看出了資源可以被多個指標共享，它使用計數機制來表明資源被幾個指標共享。可以通過成員函式use_count()來檢視資源的所有者個數。除了可以通過new來構造，還可以通過傳入auto_ptr, unique_ptr,weak_ptr來構造。當我們呼叫release()時，當前指標會釋放資源所有權，計數減一。當計數等於0時，資源會被釋放。
shared_ptr 是為了解決 auto_ptr 在物件所有權上的侷限性(auto_ptr 是獨佔的), 在使用引用計數的機制上提供了可以共享所有權的智慧指標。
成員函式：
use_count 返回引用計數的個數
unique 返回是否是獨佔所有權( use_count 為 1)
swap 交換兩個 shared_ptr 物件(即交換所擁有的物件)
reset 放棄內部物件的所有權或擁有物件的變更, 會引起原有物件的引用計數的減少
get 返回內部物件(指標), 由於已經過載了()方法, 因此和直接使用物件是一樣的.如
cppshared_ptr<int> sp(new int(1));
sp 與 sp.get()是等價的。
share_ptr的簡單例子：
cppint main()
{
string *s1 = new string("s1");
shared_ptr<string> ps1(s1);
shared_ptr<string> ps2;
ps2 = ps1;
cout << ps1.use_count()<<endl; //2
cout<<ps2.use_count()<<endl; //2
cout << ps1.unique()<<endl; //0
string *s3 = new string("s3");
shared_ptr<string> ps3(s3);
cout << (ps1.get()) << endl; //033AEB48
cout << ps3.get() << endl; //033B2C50
swap(ps1, ps3); //交換所擁有的物件
cout << (ps1.get())<<endl; //033B2C50
cout << ps3.get() << endl; //033AEB48
cout << ps1.use_count()<<endl; //1
cout << ps2.use_count() << endl; //2
ps2 = ps1;
cout << ps1.use_count()<<endl; //2
cout << ps2.use_count() << endl; //2
ps1.reset(); //放棄ps1的擁有權，引用計數的減少
cout << ps1.use_count()<<endl; //0
cout << ps2.use_count()<<endl; //1
}
weak_ptr
share_ptr雖然已經很好用了，但是有一點share_ptr智慧指標還是有記憶體洩露的情況，當兩個物件相互使用一個shared_ptr成員變數指向對方，會造成迴圈引用，使引用計數失效，從而導致記憶體洩漏。
weak_ptr 是一種不控制物件生命週期的智慧指標, 它指向一個 shared_ptr 管理的物件. 進行該物件的記憶體管理的是那個強引用的shared_ptr， weak_ptr只是提供了對管理物件的一個訪問手段。weak_ptr 設計的目的是為配合 shared_ptr 而引入的一種智慧指標來協助 shared_ptr 工作, 它只可以從一個 shared_ptr 或另一個 weak_ptr 物件構造, 它的構造和析構不會引起引用記數的增加或減少。weak_ptr是用來解決shared_ptr相互引用時的死鎖問題,如果說兩個shared_ptr相互引用,那麼這兩個指標的引用計數永遠不可能下降為0,資源永遠不會釋放。它是對物件的一種弱引用，不會增加物件的引用計數，和shared_ptr之間可以相互轉化，shared_ptr可以直接賦值給它，它可以通過呼叫lock函式來獲得shared_ptr。
cppclass B; //宣告
class A
{
public:
shared_ptr<B> pb_;
~A()
{
cout << "A delete\n";
}
};
class B
{
public:
shared_ptr<A> pa_;
~B()
{
cout << "B delete\n";
}
};
void fun()
{
shared_ptr<B> pb(new B());
shared_ptr<A> pa(new A());
cout << pb.use_count() << endl; //1
cout << pa.use_count() << endl; //1
pb->pa_ = pa;
pa->pb_ = pb;
cout << pb.use_count() << endl; //2
cout << pa.use_count() << endl; //2
}
int main()
{
fun();
return 0;
}
可以看到fun函式中pa ，pb之間互相引用，兩個資源的引用計數為2，當要跳出函式時，智慧指標pa，pb析構時兩個資源引用計數會減1，但是兩者引用計數還是為1，導致跳出函式時資源沒有被釋放（A、B的解構函式沒有被呼叫）執行結果沒有輸出解構函式的內容，造成記憶體洩露。如果把其中一個改為weak_ptr就可以了，我們把類A裡面的shared_ptr pb_，改為weak_ptr pb_ ，執行結果如下：
cpp1
1
1
2
B delete
A delete
這樣的話，資源B的引用開始就只有1，當pb析構時，B的計數變為0，B得到釋放，B釋放的同時也會使A的計數減1，同時pa析構時使A的計數減1，那麼A的計數為0，A得到釋放。
注意：我們不能通過weak_ptr直接訪問物件的方法，比如B物件中有一個方法print()，我們不能這樣訪問，pa->pb_->print()，因為pb_是一個weak_ptr，應該先把它轉化為shared_ptr，如：
cppshared_ptr<B> p = pa->pb_.lock();
p->print();
weak_ptr 沒有過載*和->但可以使用 lock 獲得一個可用的 shared_ptr 物件. 注意, weak_ptr 在使用前需要檢查合法性.
expired 用於檢測所管理的物件是否已經釋放, 如果已經釋放, 返回 true; 否則返回 false.
lock 用於獲取所管理的物件的強引用(shared_ptr). 如果 expired 為 true, 返回一個空的 shared_ptr; 否則返回一個 shared_ptr, 其內部物件指向與 weak_ptr 相同.
use_count 返回與 shared_ptr 共享的物件的引用計數.
reset 將 weak_ptr 置空.
weak_ptr 支援拷貝或賦值, 但不會影響對應的 shared_ptr 內部物件的計數.
share_ptr和weak_ptr的核心實現
weakptr的作為弱引用指標，其實現依賴於counter的計數器類和share_ptr的賦值，構造，所以先把counter和share_ptr簡單實現
Counter簡單實現
cppclass Counter
{
public:
Counter() : s(0), w(0){};
int s; //share_ptr的引用計數
int w; //weak_ptr的引用計數
};
counter物件的目地就是用來申請一個塊記憶體來存引用基數，s是share_ptr的引用計數，w是weak_ptr的引用計數，當w為0時，刪除Counter物件。
share_ptr的簡單實現
cpptemplate <class T>
class WeakPtr; //為了用weak_ptr的lock()，來生成share_ptr用，需要拷貝構造用
template <class T>
class SharePtr
{
public:
SharePtr(T *p = 0) : _ptr(p)
{
cnt = new Counter();
if (p)
cnt->s = 1;
cout << "in construct " << cnt->s << endl;
}
~SharePtr()
{
release();
}
SharePtr(SharePtr<T> const &s)
{
cout << "in copy con" << endl;
_ptr = s._ptr;
(s.cnt)->s++;
cout << "copy construct" << (s.cnt)->s << endl;
cnt = s.cnt;
}
SharePtr(WeakPtr<T> const &w) //為了用weak_ptr的lock()，來生成share_ptr用，需要拷貝構造用
{
cout << "in w copy con " << endl;
_ptr = w._ptr;
(w.cnt)->s++;
cout << "copy w construct" << (w.cnt)->s << endl;
cnt = w.cnt;
}
SharePtr<T> &operator=(SharePtr<T> &s)
{
if (this != &s)
{
release();
(s.cnt)->s++;
cout << "assign construct " << (s.cnt)->s << endl;
cnt = s.cnt;
_ptr = s._ptr;
}
return *this;
}
T &operator*()
{
return *_ptr;
}
T *operator->()
{
return _ptr;
}
friend class WeakPtr<T>; //方便weak_ptr與share_ptr設定引用計數和賦值
protected:
void release()
{
cnt->s--;
cout << "release " << cnt->s << endl;
if (cnt->s < 1)
{
delete _ptr;
if (cnt->w < 1)
{
delete cnt;
cnt = NULL;
}
}
}
private:
T *_ptr;
Counter *cnt;
};
share_ptr的給出的函式介面為：構造，拷貝構造，賦值，解引用，通過release來在引用計數為0的時候刪除_ptr和cnt的記憶體。
weak_ptr簡單實現
cpptemplate <class T>
class WeakPtr
{
public: //給出預設構造和拷貝構造，其中拷貝構造不能有從原始指標進行構造
WeakPtr()
{
_ptr = 0;
cnt = 0;
}
WeakPtr(SharePtr<T> &s) : _ptr(s._ptr), cnt(s.cnt)
{
cout << "w con s" << endl;
cnt->w++;
}
WeakPtr(WeakPtr<T> &w) : _ptr(w._ptr), cnt(w.cnt)
{
cnt->w++;
}
~WeakPtr()
{
release();
}
WeakPtr<T> &operator=(WeakPtr<T> &w)
{
if (this != &w)
{
release();
cnt = w.cnt;
cnt->w++;
_ptr = w._ptr;
}
return *this;
}
WeakPtr<T> &operator=(SharePtr<T> &s)
{
cout << "w = s" << endl;
release();
cnt = s.cnt;
cnt->w++;
_ptr = s._ptr;
return *this;
}
SharePtr<T> lock()
{
return SharePtr<T>(*this);
}
bool expired()
{
if (cnt)
{
if (cnt->s > 0)
{
cout << "empty" << cnt->s << endl;
return false;
}
}
return true;
}
friend class SharePtr<T>; //方便weak_ptr與share_ptr設定引用計數和賦值
protected:
void release()
{
if (cnt)
{
cnt->w--;
cout << "weakptr release" << cnt->w << endl;
if (cnt->w < 1 && cnt->s < 1)
{
//delete cnt;
cnt = NULL;
}
}
}
private:
T *_ptr;
Counter *cnt;
};
weak_ptr一般通過share_ptr來構造，通過expired函式檢查原始指標是否為空，lock來轉化為share_ptr。