C#、Java、python和go等語言中都有垃圾自動回收機制，在對象失去引用的時候自動回收，而且基本上沒有指針的概念，而C++語言不一樣，C++充分信任程序員，讓程序員自己去分配和管理堆內存，如果管理的不好，就會很容易的發生內存泄漏問題，而C++11增加了智能指針(Smart Pointer)。主要分為shared_ptr、unique_ptr和weak_ptr三種，使用時需要引用頭文件<memory>。c++98中還有auto_ptr，基本被淘汰了，不推薦使用。而c++11中shared_ptr和weak_ptr都是參考的boost庫中實現的。
本文有很多代碼片段，如果不喜歡簡書的代碼風格，請移步我的SegmentFault博客。
原始指針
c語言中最常使用的是malloc()函數分配內存，free()函數釋放內存，而c++中對應的是new、delete關鍵字。malloc()只是分配了內存，而new則更進一步，不僅分配了內存，還調用了構造函數進行初始化。使用示例：
int main()
{
// malloc返回值是 void*
int* argC = (int*)malloc(sizeof(int));
free(argC);
char*c = (char*)malloc(100);
free(c);
char *age = new int(25); //做了兩件事情 1.分配內存 2.初始化
int* height = new int(160);
delete height;
delete age;
char* arr = new int[100];
delete[] arr;
/*delete數組需要使用delete[]，事實上，c++原始支持的數據結構組成的
數組不需要[]也可以，但 自定義的數據類型組成的數組必須使用delete[]*/
}
new和delete必須成對出現，有時候是不小心忘記了delete，有時候則是很難判斷在這個地方自己是不是該delete，這個和資源的生命周期有關，這個資源是屬于我這個類管理的還是由另外一個類管理的，如果是我管理的，就由我來delete，由別人管理的就由別人delete，我就算析構了也不影響該資源的生命周期。例如：
// 情況1： 需要自己delete
const char* getName() {
char *valueGroup = new char[1000];
// do something
return valueGroup;
}
// 情況2： 不需要自己delete
const char* getName2() {
static char valueGroup[1000];
// do something
return valueGroup;
}
只通過函數簽名來看，這兩個函數沒有什么區別，但是由于實現的不同，有時候需要自己管理內存，有時候不需要，這個時候就需要看文檔說明了。這就是使用一個"裸"指針不好的地方。
一點改進是，如果需要自己管理內存的話，最好顯示的將自己的資源傳遞進去，這樣的話，就能知道是該資源確實應該由自己來管理。
char *getName(char* v, size_t bufferSize) {
//do something
return v;
}
上面還是小問題，自己小心一點，再仔細看看文檔，還是有機會避免這些情況的。但是在c++引入異常的概念之后，程序的控制流就發生了根本性的改變，在寫了delete的時候還是有可能發生內存泄漏。如下例：
void badThing(){
throw 1;// 拋出一個異常
}
void test() {
char* a = new char[1000];
badThing();
// do something
delete[] a;
}
int main() {
try {
test();
}
catch (int i){
cout << "error happened " << i << endl;
}
}
上面的new和delete是成對出現的，但是程序在中間的時候拋出了異常，由于沒有立即捕獲，程序從這里退出了，并沒有執行到delete，內存泄漏還是發生了。
C++中的構造函數和析構函數十分強大，可以使用構造和析構解決這種問題，比如：
class SafeIntPointer {
public:
explicit SafeIntPointer(int v) : m_value(new int(v)) { }
~SafeIntPointer() {
delete m_value;
cout << "~SafeIntPointer" << endl;
}
int get() { return *m_value; }
private:
int* m_value;
};
void badThing(){
throw 1;// 拋出一個異常
}
void test() {
SafeIntPointer a(5);
badThing();
}
int main() {
try {
test();
}
catch (int i){
cout << "error happened " << i << endl;
}
}
// 結果
// ~SafeIntPointer
// error happened 1
可以看到，就算發生了異常，也能夠保證析構函數成功執行！這里的例子是這個資源只有一個人使用，我不用了就將它釋放掉。但還有種情況，一份資源被很多人共同使用，要等到所有人都不再使用的時候才能釋放掉，對于這種問題，就需要對上面的SafeIntPointer增加一個引用計數，如下：
class SafeIntPointer {
public:
explicit SafeIntPointer(int v) : m_value(new int(v)), m_used(new int(1)) { }
~SafeIntPointer() {
cout << "~SafeIntPointer" << endl;
(*m_used) --; //引用計數減1
if(*m_used <= 0){
delete m_used;
delete m_value;
cout << "real delete resources" << endl;
}
}
SafeIntPointer(const SafeIntPointer& other) {
m_used = other.m_used;
m_value = other.m_value;
(*m_used)++; //引用計數加1
}
SafeIntPointer& operator= (const SafeIntPointer& other) {
if (this == &other) // 避免自我賦值!!
return *this;
m_used = other.m_used;
m_value = other.m_value;
(*m_used)++; //引用計數加1
return *this;
}
int get() { return *m_value; }
int getRefCount() {
return *m_used;
}
private:
int* m_used;
int* m_value;
};
int main() {
SafeIntPointer a(5);
cout << "ref count = " << a.getRefCount() << endl;
SafeIntPointer b = a;
cout << "ref count = " << a.getRefCount() << endl;
SafeIntPointer c = b;
cout << "ref count = " << a.getRefCount() << endl;
}
/*
ref count = 1
ref count = 2
ref count = 3
~SafeIntPointer
~SafeIntPointer
~SafeIntPointer
real delete resources
*/
可以看到每一次賦值，引用計數都加一，最后每次析構一次后引用計數減一，知道引用計數為0，才真正釋放資源。要寫出一個正確的管理資源的包裝類還是蠻難的，比如上面那個上面例子就不是線程安全的，只能屬于一個玩具，在實際工程中簡直沒法用。而到了C++11，終于提供了一個共享的智能指針解決這個問題。
shared_ptr共享的智能指針
shared_ptr的基本使用
shared_ptr的基本使用很簡單，看幾個例子就明白了：
#include <iostream>
#include <memory>
class Object {
public:
Object(int id) : m_id(id) {
std::cout << "init obj " << std::endl;
}
~Object() {
std::cout << "bye bye" << m_id << std::endl;
}
int id() const {
return m_id;
}
private:
int m_id;
};
// 取個別名 讓寫起來更方便
typedef std::shared_ptr<Object> ObjectPtr;
void print(Object* obj) {
std::cout << "in print(Object* obj) : " << std::endl;
// std::cout << "ref count is " << obj.use_count() << std::endl;
}
void print(Object obj) {
std::cout << "in print(Object obj) : " << std::endl;
// std::cout << "ref count is " << obj.use_count() << std::endl;
}
void print(ObjectPtr obj) {
std::cout << "in print(ObjectPtr obj) : ";
std::cout << "ref count is " << obj.use_count() << std::endl;
}
void printRef(const ObjectPtr& obj) {
std::cout << "in print(const ObjectPtr& obj) : ";
std::cout << "ref count is " << obj.use_count() << std::endl;
}
int main() {
// 創建一個智能指針，管理的資源就是 new出來的Object(1)
//ObjectPtr obj=new Object(1); //不能將一個原始指針直接賦值給一個智能指針
ObjectPtr obj(new Object(1)); // 正確
std::cout << "ref count is " << obj.use_count() << std::endl; // 1
ObjectPtr obj2(obj);
std::cout << "ref count is " << obj.use_count() << std::endl; // 2
std::cout << "ref count is " << obj2.use_count() << std::endl; // 2 obj和obj2管理的資源是一樣的
ObjectPtr obj3 = obj2;
std::cout << "ref count is " << obj.use_count() << std::endl; // 3
obj2.reset(); // obj2不再管理之前的資源，資源的引用計數會減1
// 或者可以寫成 obj2 = nullptr;
std::cout << "ref count is " << obj.use_count() << std::endl; // 2
ObjectPtr obj4; //obj4 開始沒有管理資源
// 將管理的資源 相互交換
// 交換后 obj3沒有再管理資源， obj4管理obj3之前管理的資源
// 或者寫成 std::swap(obj3, obj4);
obj3.swap(obj4);
std::cout << "ref count is " << obj.use_count() << std::endl; // 還是 2
// 還可以從智能指針中獲取原始指針
auto p = obj.get(); // auto = Object*
// 需要判斷這個obj是否確實管理著資源， 可能為 nullptr
if( p ) {
std::cout << "p->id() is " << p->id() << std::endl;
std::cout << "(*p).id() is " << (*p).id() << std::endl;
}
// 智能指針也可以像普通指針一樣使用
// 重載了 operator bool
if( obj ) {
std::cout << "obj->id() is " << obj->id() << std::endl; // 重載了operator ->
std::cout << "(*obj).id() is " << (*obj).id() << std::endl;// 重載了operator *
}
// obj.use_count()可以判斷當前有多少智能指針在管理資源
// 如果判斷是不是只有一個人在管理這個資源， 用unique()函數更加高效
// unique() 等價于 obj.use_count() == 1
obj4 = nullptr; // obj4不在管理，這個時候的引用計數變成了 1
std::cout << "ref count is " << obj.use_count() << std::endl; // 1
if( obj.unique() )
std::cout << "only one hold ptr "<< std::endl;
else
std::cout << "not noly one hold ptr" << std::endl; //其實也有可能沒有人再管理
// 將智能指針當作參數傳遞給函數時
// 如果是值傳遞， 智能指針發生一次拷貝，
// 在函數內部時智能指針的引用計數會 + 1
// 離開函數作用域時， 智能指針會析構， 引用計數會 - 1
print(obj);
// 如果傳遞的是引用， 對引用計數沒影響 而且工作量比較小(沒有拷貝)
// 推薦使用引用方式傳遞， 傳值的方式也有用處，比如多線程時
printRef(obj);
// 還可以不傳遞智能指針， 傳遞原生類型
print(*obj); //傳Object類型的時候，離開函數的時候參數obj會發生一次析構
print(obj.get());
}
/*
init obj
ref count is 1
ref count is 2
ref count is 2
ref count is 3
ref count is 2
ref count is 2
p->id() is 1
(*p).id() is 1
obj->id() is 1
(*obj).id() is 1
ref count is 1
only one hold ptr
in print(ObjectPtr obj) : ref count is 2
in print(const ObjectPtr& obj) : ref count is 1
in print(Object obj) :
bye bye1 //這個是在調用print(Object obj)時，局部變量析構時打印的
in print(Object* obj) :
bye bye1 //這個是在資源在沒有人引用的時候，執行析構函數產生的
*/
給shared_ptr指定刪除器
大部分用法都基本上在上面的例子中體現出來了，當沒有人引用這個資源的時候，智能指針的默認行為是調用 delete銷毀這個資源，而我們也可以人為指定這個步驟，因為有些資源不一定是new出來的，所以不應該使用默認的delete行為，還有一個情況是，在用智能指針管理動態數組的時候，需要自己指定刪除器函數。
#include <iostream>
#include <memory>
class Object {
public:
Object(int id) : m_id(id) {
std::cout << "init obj " << std::endl;
}
~Object() {
std::cout << "bye bye" << m_id << std::endl;
}
int id() const {
return m_id;
}
private:
int m_id;
};
// 讓寫起來更方便
typedef std::shared_ptr<Object> ObjectPtr;
void deleterOfObject(Object* obj) {
if ( obj ) {
std:: cout << "delete obj " << obj->id() << std::endl;
delete obj;
}
}
void useDeleter() {
//指定刪除動作 使用外面定義的函數
ObjectPtr obj(new Object(2), deleterOfObject);
ObjectPtr obj2 = obj;
// obj 和 obj2 會在離開這個函數的時候析構，于是，就調用了 deleterOfObject
//管理數組 使用匿名函數當作刪除函數
std::shared_ptr<int> p(new int[10], [](int* p){
std::cout << "delete[] p" << std::endl;
delete[] p; //需要使用delete[]
});
// vector<> 沒必要使用智能指針， 不用new 和 delete... 內部已經管理了
}
int main() {
useDeleter();
}
/*
init obj
delete[] p //注意析構和構造的順序是相反的
delete obj 2
bye bye2
*/
shared_ptr主要就是利用變量出了作用域之后析構函數一定能被調用到，哪怕是出現了異常。
不要用一個原始的指針初始化多個shared_ptr
例如下面的例子：
#include <iostream>
#include <memory>
class Object {
public:
Object(int id) : m_id(id) {
std::cout << "init obj " << std::endl;
}
~Object() {
std::cout << "bye bye " << m_id << std::endl;
}
int id() const {
return m_id;
}
private:
int m_id;
};
// 讓寫起來更方便
typedef std::shared_ptr<Object> ObjectPtr;
int main() {
Object *obj = new Object(2);
ObjectPtr p1(obj);
ObjectPtr p2(obj);
std::cout << p1.use_count() << " " << p2.use_count() << std::endl;
std::cout << "finished" << std::endl;
}
/*
init obj
1 1
finished
bye bye 2
bye bye 203200 //m_id成為了隨機數
*/
可以發現，雖然是用的同一個指針初始化了兩個shared_ptr，但是這兩個shared_ptr卻沒有關聯，它們的引用計數都是1，然后問題就發生了，p2先析構，于是引用計數變為了0，就開始刪除它管理的資源obj，于是obj就被析構了，這是還算正常，接著析構p1，引用計算也變成了0，它也開始刪除自己管理的資源obj，相當于多次delete了同一個對象，m_id成為了隨機數，這還算好的情況，如果Object內部還有指針，或者obj的地址被其他變量占據了，delete掉這塊內存就會發生嚴重的錯誤！而且不好發現原因。
將this指針正確的傳遞給shared_ptr
其實就是由于上面的原因，我們不可能傳遞this指針給shared_ptr，因為用同一個指針初始化兩個shared_ptr，它們之間并沒有關聯，如下面的例子：
#include <iostream>
#include <memory>
class Y
{
public:
std::shared_ptr<Y> f(){
return std::shared_ptr<Y>(this);
}
};
int main()
{
std::shared_ptr<Y> p1(new Y());
std::shared_ptr<Y> p2 = p1->f(); // p2是由this構造共享智能指針
std::cout << p1.use_count() << " " << p2.use_count() << std::endl; // 1 1
}
從上面的例子可以看出，返回由this構造的shared_ptr并沒有用，返回還可能造成嚴重錯誤(由于可能多次delete)！解決辦法是繼承std::enable_shared_from_this<Y>，然后使用shared_from_this()構造shared_ptr。
#include <iostream>
#include <memory>
class Y : public std::enable_shared_from_this<Y>
{
public:
std::shared_ptr<Y> f(){
return shared_from_this();
}
};
int main()
{
std::shared_ptr<Y> p1(new Y());
std::shared_ptr<Y> p2 = p1->f(); // p2是由p1的thiss構造共享智能指針
std::cout << p1.use_count() << " " << p2.use_count() << std::endl; // 2 2
std::shared_ptr<Y> p3(new Y());
std::shared_ptr<Y> p4 = p3->f(); // p4是由p3的this構造的構造共享智能指針
std::cout << p1.use_count() << " " << p2.use_count() << " "
<< p3.use_count() << " " << p4.use_count() << std::endl; // 2 2 2 2
}
可以發現引用計數確實增加了。并且由p1得到的shared_from_this()增加的就是p1的引用計數，p3得到的shared_from_this()增加的就是p3的引用計數，這和this的含義是一樣的。所以我們在類內部需要傳遞this指針給shared_ptr時，需要繼承自std::enable_shared_from_this<T>，并且使用shared_from_this()替代this。而shared_from_this()就是借助了weak_ptr。原理在后面再講。
shared_ptr的正確構造方式
其實上面使用的智能指針構造方式有一點點問題，ObjectPtr obj(new Object(1));這一個語句其實調用了兩次new，一次是new Object(1)，另一次是構造內部的引用計數變量的時候，那有沒有辦法只掉用一次new呢，答案就是使用make_shared<T>()模板函數，它將資源和引用計數變量一起new出來，例如：
#include <iostream>
#include <memory>
#include <cassert>
class Object {
public:
Object(int id) : m_id(id) {
std::cout << "init obj " << std::endl;
}
~Object() {
std::cout << "bye bye " << m_id << std::endl;
}
int id() const {
return m_id;
}
private:
int m_id;
};
// 讓寫起來更方便
typedef std::shared_ptr<Object> ObjectPtr;
int main() {
// 和 ObjectPtr obj(new Object(2)); 一樣
// 但是只調用了一次new
ObjectPtr obj = std::make_shared<Object>(2);
}
然而，這個函數也有失效的時候，如果管理的資源對象的構造函數是私有的他就沒有辦法了。
weak_ptr弱引用的智能指針
循環引用問題的引出
在有些情況下，shared_ptr也會遇見很尷尬、不能處理的情況，那就是循環引用，看下面的例子：
#include <iostream>
#include <memory>
class Parent; //Parent類的前置聲明
typedef std::shared_ptr<Parent> ParentPtr;
class Child {
public:
ParentPtr father;
~Child() {
std::cout << "bye child" << std::endl;
}
};
typedef std::shared_ptr<Child> ChildPtr;
class Parent {
public:
ChildPtr son;
~Parent() {
std::cout << "bye parent" << std::endl;
}
};
void testParentAndChild() {
ParentPtr p(new Parent()); // 1 資源A
ChildPtr c(new Child()); // 2 資源B
p->son = c; // 3 c.use_count() == 2 and p.use_count() == 1
c->father = p; // 4 c.use_count() == 2 and p.use_count() == 2
}
int main() {
testParentAndChild();
std::cout << "finished" << std::endl;
}
/*
// 沒有調用Parent 和 Child 的析構函數
finished
*/
很驚訝的發現，用了shared_ptr管理資源，資源最后還是沒有釋放！內存泄漏還是發生了。
分析：
- 執行編號
1的語句時，構造了一個共享智能指針p，稱呼它管理的資源叫做資源A（new Parent()產生的對象）吧， 語句2構造了一個共享智能指針c，管理資源B(new Child()產生的對象)，此時資源A和B的引用計數都是1，因為只有1個智能指針管理它們，執行到了語句3的時候，是一個智能指針的賦值操作，資源B的引用計數變為了2，同理，執行完語句4，資源A的引用計數也變成了2。 - 出了函數作用域時，由于析構和構造的順序是相反的，會先析構共享智能指針
c，資源B的引用計數就變成了1；接下來繼續析構共享智能指針p，資源A的引用計數也變成了1。由于資源A和B的引用計數都不為1，說明還有共享智能指針在使用著它們，所以不會調用資源的析構函數！ - 這種情況就是個死循環，如果資源
A的引用計數想變成0，則必須資源B先析構掉(從而析構掉內部管理資源A的共享智能指針)，資源B的引用計數想變為0，又得依賴資源A的析構，這樣就陷入了一個死循環。
要想解決這個問題，只能引入新的智能指針weak_ptr，顧名思義，弱引用，也就是不增加引用計數，它不管理shared_ptr內部管理的指針，他只是起一個監視的作用。它監視的不是shared_ptr本身，而是shared_ptr管理的資源！！！weak_ptr沒有重載操作符*和->，它不能直接操作資源，但是它可以獲取所監視的shared_ptr(如果資源還沒有被析構的話)。
weak_ptr的基本用法
weak_ptr使用示例：
#include <iostream>
#include <memory>
class Object {
public:
Object(int id) : m_id(id) {
std::cout << "init obj " << std::endl;
}
~Object() {
std::cout << "bye bye" << m_id << std::endl;
}
int id() const {
return m_id;
}
private:
int m_id;
};
// 取個別名 讓寫起來更方便
typedef std::shared_ptr<Object> ObjectPtr;
void sharedPtrWithWeakPtr() {
ObjectPtr obj(new Object(1));
typedef std::weak_ptr<Object> WeakObjectPtr;
WeakObjectPtr weakObj(obj); //使用共享指針 初始化 弱引用指針
//weakObj 僅僅是一個監聽者，不會增加引用計數
std::cout << "obj use count is " << obj.use_count() << std::endl; // 1
{
// lock() 方法返回一個 它對應的共享指針
// 下面這句話的結果是 2, 而不是1，
// 說明weakObj.lock() 內部也得到了一個新的共享指針，所以引用計數+1
// 在執行完這句話后就析構掉了，引用計數-1
std::cout << "weakObj.lock().use_count() is " << weakObj.lock().use_count() << std::endl; // 2
// 由于發生了一次 賦值 ，所以 引用次次數 +1
// auto === ObjectPtr
auto p = weakObj.lock(); //如果weakObj監視的資源存在， p就存在
std::cout << "obj use count is " << obj.use_count() << std::endl; // 2
if ( p ) {
// do what you want to do
} else {
}
}
// 共享指針不再管理任何資源的時候，weakObj的行為
// 注意：如果在obj.reset前，還存在共享指針管理它的資源
// 如 ：ObjectPtr obj1(obj); weakObj.lock();還是有效的
obj.reset();
{
auto p = weakObj.lock();
if( p ) {
//不應該到這里來
std::cout << "weakObj is not null 1" << std::endl;
} else {
std::cout << "weakObj is null 1" << std::endl;
}
}
// 共享指針管理其他資源的時候，weakObj的行為
// 注意：weak_ptr.lock()
// 只有在 存在某一個shared_ptr管理的資源和該weak_ptr一樣 的時候才有效果！
obj.reset(new Object(2));
{
auto p = weakObj.lock();
if( p ) {
//不應該到這里來
std::cout << "weakObj is not null 2" << std::endl;
} else {
std::cout << "weakObj is null 2" << std::endl;
}
}
weakObj = obj; // 重新監視 obj
// 用weakObj 判斷管理的資源是否過期
if(weakObj.expired()) {
} else {
}
}
int main() {
sharedPtrWithWeakPtr();
std::cout << "finished" << std::endl;
}
/*
init obj
obj use count is 1
weakObj.lock().use_count() is 2
obj use count is 2
bye bye1
weakObj is null 1
init obj
weakObj is null 2
bye bye2
finished
*/
由上面的例子可以看出，weak_ptr和初始化它的share_ptr沒有關系，而是和share_ptr管理的資源有關系。假如WeakObjectPtr weakObj(obj);，如果obj.reset()，weakObj.lock()的返回值就是空，如果obj.reset(new Object(2));，替換了管理對象，則一起的資源就被析構了，weakObj.lock()的返回值同樣為空，同樣可以推斷，如果除了obj以外還有其他共享智能指針一起管理資源，也就是說obj.reset()的時候資源不會被析構，weakObj.lock();的返回值就不會為空了。不明白的話自己寫個簡單的測試用例就知道了，如：
void sharedPtrWithWeakPtr() {
ObjectPtr obj(new Object(1));
typedef std::weak_ptr<Object> WeakObjectPtr;
WeakObjectPtr weakObj(obj); //使用共享指針 初始化 弱引用指針
ObjectPtr obj1 = obj; //注釋掉這句話打印的就是error， 加上這句話打印的就是ok
obj.reset();
auto p = weakObj.lock();
if( p ) {
std::cout << "ok" << std::endl;
} else {
std::cout << "error" << std::endl;
}
}
weak_ptr解決循環引用
用weak_ptr可以解決上面的循環引用問題，將Child內部的parent指針換成weak_ptr管理：
#include <iostream>
#include <memory>
class Parent; //Parent類的前置聲明
typedef std::shared_ptr<Parent> ParentPtr;
typedef std::weak_ptr<Parent> WeakParentPtr;
class Child {
public:
WeakParentPtr father;
~Child() {
std::cout << "bye child" << std::endl;
}
};
typedef std::shared_ptr<Child> ChildPtr;
//typedef std::weak_ptr<Child> WeakChildPtr;
class Parent {
public:
//WeakChildPtr son;
ChildPtr son;
~Parent() {
std::cout << "bye parent" << std::endl;
}
};
void testParentAndChild() {
ParentPtr p(new Parent()); // 1 資源A
ChildPtr c(new Child()); // 2 資源B
p->son = c; // 3 c.use_count() == 2 and p.use_count() == 1
c->father = p; // 4 c.use_count() == 2 and p.use_count() == 1
}
int main() {
testParentAndChild();
std::cout << "finished" << std::endl;
}
/*
bye parent //成功調用析構函數
bye child
finished
*/
修改為弱引用后，成功的釋放了資源，只要將任意一個shared_ptr換成weak_ptr，就可以解決問題。當然，也可以兩個都換成weak_ptr，至于這三種方案誰更好，就暫時不清楚了。
shared_from_this()實現原理
std::enable_shared_from_this<T>模板類中有一個weak_ptr，這個weak_ptr用來觀測this智能指針，調用shared_from_this()函數的時候，會在內部調用weak_ptr的lock()方法，將所觀測的shared_ptr返回。這個設計要依賴于當前對象已經有了一個相應的控制塊。為此，必須已經存在一個指向當前對象的shared_ptr（比如在調用過shared_from_this()成員函數之外已經有了一個）。假如沒有這樣shared_ptr存在，那么shared_from_this()會拋異常。 那么這個weak_ptr在什么時候賦值的呢？答案就是在外部第一次構造shared_ptr的時候(如之前的std::shared_ptr<Y> p1(new Y());)，對std::enable_shared_from_this<T>進行了賦值（具體實現有點復雜，還不太懂。。），這也就為什么在調用shared_from_this()時，必須存在一個指向當前對象的shared_ptr的原因了。由于這個原因，不要在構造函數中調用shared_from_this()，如：
#include <iostream>
#include <memory>
class Y : public std::enable_shared_from_this<Y>
{
public:
Y() {
std::shared_ptr<Y> p = shared_from_this();
}
std::shared_ptr<Y> f(){
return shared_from_this();
}
};
int main()
{
std::shared_ptr<Y> p1(new Y());
}
// 會拋出異常！
/*
terminate called after throwing an instance of 'std::bad_weak_ptr'
what(): bad_weak_ptr
*/
unique_ptr獨占的智能指針
unique_ptr相對于其他兩個智能指針更加簡單，它和shared_ptr使用差不多，但是功能更為單一，它是一個獨占型的智能指針，不允許其他的智能指針共享其內部的指針，更像原生的指針（但更為安全，能夠自己釋放內存）。不允許賦值和拷貝操作，只能夠移動。
#include <iostream>
#include <memory>
#include <cassert>
class Object {
public:
Object(int id) : m_id(id) {
std::cout << "init obj " << std::endl;
}
~Object() {
std::cout << "bye bye " << m_id << std::endl;
}
int id() const {
return m_id;
}
private:
int m_id;
};
// 讓寫起來更方便
typedef std::shared_ptr<Object> ObjectPtr;
typedef std::unique_ptr<Object> UniqueObjectPtr;
// 只能傳遞引用 不能傳值
void print(const UniqueObjectPtr& obj) {
std::cout << obj->id() << std::endl;
}
int main() {
UniqueObjectPtr obj(new Object(1));
// UniqueObjectPtr obj1 = obj; // 編譯錯誤，不允許賦值
// 獲取原生指針
auto p = obj.get();
if( p ) {
} else {
}
// better 重載了 operator bool
if(obj) {
} else {
}
// 重載了 operator -> 和 operator *
std::cout << obj->id() << " " << (*obj).id() << std::endl;
print(obj);
// 釋放管理的指針，由其他東西處理
p = obj.release();
// delete p; 自己負責處理
obj.reset(p); //析構之前負責管理的對象，重新管理 p指針
obj.reset(); // 析構之前負責管理的對象， 不再管理任何資源
// 允許 移動操作
UniqueObjectPtr obj1(new Object(1));
// obj1已經部管理任何資源 obj2開始管理obj1之前的資源
UniqueObjectPtr obj2 = std::move(obj1);
assert(obj1 == nullptr);
std::cout << obj2->id() << std::endl;
// 將unique_ptr管理的內容給 shared_ptr
ObjectPtr obj3(std::move(obj2));
assert(obj2 == nullptr);
}
/*
init obj
1 1
1
bye bye 1
init obj
1
bye bye 1
*/
unique_ptr管理數組資源不需要指定刪除器：
std::shared_ptr<int> p(new int[10], [](int* p){
std::cout << "delete[] p" << std::endl;
delete[] p; //需要使用delete[]
});
std::unique_ptr<int> p2(new int[10]); //不需要指定刪除器
性能與安全的權衡
使用智能指針雖然能夠解決內存泄漏問題，但是也付出了一定的代價。以shared_ptr舉例：
-
shared_ptr的大小是原始指針的兩倍，因為它的內部有一個原始指針指向資源，同時有個指針指向引用計數。 - 引用計數的內存必須動態分配。雖然一點可以使用
make_shared()來避免，但也存在一些情況下不能夠使用make_shared()。 - 增加和減小引用計數必須是原子操作，因為可能會有讀寫操作在不同的線程中同時發生。比如在一個線程里有一個指向一塊資源的
shared_ptr可能調用了析構（因此所指向的資源的引用計數減一），同時，在另一線程里，指向相同對象的一個shared_ptr可能執行了拷貝操作（因此，引用計數加一）。原子操作一般會比非原子操作慢。但是為了線程安全，又不得不這么做，這就給單線程使用環境帶來了不必要的困擾。
我覺得還是分場合吧，看應用場景來進行權衡，我也沒啥經驗，但我感覺安全更重要，現在硬件已經足夠快了，其他例如java這種支持垃圾回收的語言不還是用的很好嗎。
總結
- 智能指針主要是使用構造和析構來管理資源的。
-
shared_ptr很好用也很難用，有兩種構造方式，使用引用計數實現多人同時管理一份資源。使用this的時候要格外注意。 -
weak_ptr可以解決shared_ptr的循環引用問題。 -
unique_ptr最像裸指針，但更為安全，保證資源的釋放，不能復制只能移動。 - 智能指針帶來了性能問題，在不同場合可以選擇不同的解決方案。優先使用類的實例(如果內存足夠)，其次
unique_ptr，最后才是shared_ptr。
