C++ 智能指針 shared_ptr 詳解與示例

shared_ptr 是C++11提供的一種智能指針類，它足夠智能，可以在任何地方都不使用時自動刪除相關指針，從而幫助徹底消除內存泄漏和懸空指針的問題。
它遵循共享所有權的概念，即不同的 shared_ptr 對象可以與相同的指針相關聯，並在內部使用引用計數機制來實現這一點。
每個 shared_ptr 對象在內部指向兩個內存位置：
1、指向對象的指針。
2、用於控制引用計數數據的指針。
共享所有權如何在參考計數的幫助下工作：
1、當新的 shared_ptr 對象與指針關聯時，則在其構造函數中，將與此指針關聯的引用計數增加1。
2、當任何 shared_ptr 對象超出作用域時，則在其析構函數中，它將關聯指針的引用計數減1。如果引用計數變爲0，則表示沒有其他 shared_ptr 對象與此內存關聯，在這種情況下，它使用delete函數刪除該內存。

創建 shared_ptr 對象

使用原始指針創建 shared_ptr 對象

std::shared_ptr<int> p1(new int());

上面這行代碼在堆上創建了兩塊內存：1：存儲int。2：用於引用計數的內存，管理附加此內存的 shared_ptr 對象的計數，最初計數將爲1。
檢查 shared_ptr 對象的引用計數

p1.use_count();

創建空的 shared_ptr 對象

因爲帶有參數的 shared_ptr 構造函數是 explicit 類型的，所以不能像這樣std::shared_ptr<int> p1 = new int();隱式調用它構造函數。創建新的shared_ptr對象的最佳方法是使用std :: make_shared：

std::shared_ptr<int> p1 = std::make_shared<int>();

std::make_shared 一次性爲int對象和用於引用計數的數據都分配了內存，而new操作符只是爲int分配了內存。

分離關聯的原始指針

要使 shared_ptr 對象取消與相關指針的關聯，可以使用reset()函數：
不帶參數的reset()：

p1.reset();

它將引用計數減少1，如果引用計數變爲0，則刪除指針。
帶參數的reset()：

p1.reset(new int(34));

在這種情況下，它將在內部指向新指針，因此其引用計數將再次變爲1。
使用nullptr重置：

p1 = nullptr; 

shared_ptr是一個僞指針

shared_ptr充當普通指針，我們可以將*和->與 shared_ptr 對象一起使用，也可以像其他 shared_ptr 對象一樣進行比較;

完整示例

#include <iostream>
#include  <memory> // 需要包含這個頭文件

int main()
{
	// 使用 make_shared 創建空對象
	std::shared_ptr<int> p1 = std::make_shared<int>();
	*p1 = 78;
	std::cout << "p1 = " << *p1 << std::endl; // 輸出78

	// 打印引用個數：1
	std::cout << "p1 Reference count = " << p1.use_count() << std::endl;

	// 第2個 shared_ptr 對象指向同一個指針
	std::shared_ptr<int> p2(p1);

	// 下面兩個輸出都是：2
	std::cout << "p2 Reference count = " << p2.use_count() << std::endl;
	std::cout << "p1 Reference count = " << p1.use_count() << std::endl;

	// 比較智能指針，p1 等於 p2
	if (p1 == p2) {
		std::cout << "p1 and p2 are pointing to same pointer\n";
	}

	std::cout<<"Reset p1 "<<std::endl;

	// 無參數調用reset，無關聯指針，引用個數爲0
	p1.reset();
	std::cout << "p1 Reference Count = " << p1.use_count() << std::endl;
	
	// 帶參數調用reset，引用個數爲1
	p1.reset(new int(11));
	std::cout << "p1  Reference Count = " << p1.use_count() << std::endl;

	// 把對象重置爲NULL，引用計數爲0
	p1 = nullptr;
	std::cout << "p1  Reference Count = " << p1.use_count() << std::endl;
	if (!p1) {
		std::cout << "p1 is NULL" << std::endl; // 輸出
	}
	return 0;
}

自定義刪除器 Deleter

下面將討論如何將自定義刪除器與 std :: shared_ptr 一起使用。
當 shared_ptr 對象超出範圍時，將調用其析構函數。在其析構函數中，它將引用計數減1，如果引用計數的新值爲0，則刪除關聯的原始指針。
析構函數中刪除內部原始指針，默認調用的是delete()函數。

delete Pointer;

有些時候在析構函數中，delete函數並不能滿足我們的需求，可能還想加其他的處理。

當 shared_ptr 對象指向數組

std::shared_ptr<int> p3(new int[12]);

像這樣申請的數組，應該調用delete []釋放內存，而shared_ptr析構函數中默認delete並不能滿足需求。

給shared_ptr添加自定義刪除器

在上面在這種情況下，我們可以將回調函數傳遞給 shared_ptr 的構造函數，該構造函數將從其析構函數中調用以進行刪除，即

// 自定義刪除器
void deleter(Sample * x)
{
	std::cout << "DELETER FUNCTION CALLED\n";
	delete[] x;
}
// 構造函數傳遞自定義刪除器指針
std::shared_ptr<Sample> p3(new Sample[12], deleter);

下面看一個完整的示例：

#include <iostream>
#include <memory>

struct Sample
{
    Sample() {
        std::cout << "Sample\n";
    }
    ~Sample() {
        std::cout << "~Sample\n";
    }
};

void deleter(Sample * x)
{
    std::cout << "Custom Deleter\n";
    delete[] x;
}

int main()
{
    std::shared_ptr<Sample> p3(new Sample[3], deleter);
    return 0;
}

輸出：

Sample
Sample
Sample
Custom Deleter
~Sample
~Sample
~Sample

使用Lambda 表達式 / 函數對象作爲刪除器

class Deleter
{
	public:
	void operator() (Sample * x) {
		std::cout<<"DELETER FUNCTION CALLED\n";
		delete[] x;
	}
};

// 函數對象作爲刪除器
std::shared_ptr<Sample> p3(new Sample[3], Deleter());

// Lambda表達式作爲刪除器
std::shared_ptr<Sample> p4(new Sample[3], [](Sample * x){
	std::cout<<"DELETER FUNCTION CALLED\n";
		delete[] x;
});

shared_ptr 相對於普通指針的優缺點

缺少 ++, – – 和 [] 運算符

與普通指針相比，shared_ptr僅提供-> 、*和==運算符，沒有+、-、++、--、[]等運算符。
示例：

#include<iostream>
#include<memory>

struct Sample {
	void dummyFunction() {
		std::cout << "dummyFunction" << std::endl;
	}
};

int main()
{

	std::shared_ptr<Sample> ptr = std::make_shared<Sample>();

	(*ptr).dummyFunction(); // 正常
	ptr->dummyFunction(); // 正常

	// ptr[0]->dummyFunction(); // 錯誤方式
	// ptr++;  // 錯誤方式
	//ptr--;  // 錯誤方式

	std::shared_ptr<Sample> ptr2(ptr);
	if (ptr == ptr2) // 正常
		std::cout << "ptr and ptr2 are equal" << std::endl;
	return 0;
}

NULL檢測

當我們創建 shared_ptr 對象而不分配任何值時，它就是空的；普通指針不分配空間的時候相當於一個野指針，指向垃圾空間，且無法判斷指向的是否是有用數據。
shared_ptr 檢測空值方法

std::shared_ptr<Sample> ptr3;
if(!ptr3)
	std::cout<<"Yes, ptr3 is empty" << std::endl;
if(ptr3 == NULL)
	std::cout<<"ptr3 is empty" << std::endl;
if(ptr3 == nullptr)
	std::cout<<"ptr3 is empty" << std::endl;

創建 shared_ptr 時注意事項

不要使用同一個原始指針構造 shared_ptr

創建多個 shared_ptr 的正常方法是使用一個已存在的shared_ptr 進行創建，而不是使用同一個原始指針進行創建。
示例：

    int *num = new int(23);
    std::shared_ptr<int> p1(num);
    
    std::shared_ptr<int> p2(p1);  // 正確使用方法
    std::shared_ptr<int> p3(num); // 不推薦

    std::cout << "p1 Reference = " << p1.use_count() << std::endl; // 輸出 2
    std::cout << "p2 Reference = " << p2.use_count() << std::endl; // 輸出 2
    std::cout << "p3 Reference = " << p3.use_count() << std::endl; // 輸出 1

假如使用原始指針num創建了p1，又同樣方法創建了p3，當p1超出作用域時會調用delete釋放num內存，此時num成了懸空指針，當p3超出作用域再次delete的時候就可能會出錯。

不要用棧中的指針構造 shared_ptr 對象

shared_ptr 默認的構造函數中使用的是delete來刪除關聯的指針，所以構造的時候也必須使用new出來的堆空間的指針。
示例：

#include<iostream>
#include<memory>

int main()
{
   int x = 12;
   std::shared_ptr<int> ptr(&x);
   return 0;
}

當 shared_ptr 對象超出作用域調用析構函數delete 指針&x時會出錯。

建議使用 make_shared

爲了避免以上兩種情形，建議使用make_shared()<>創建 shared_ptr 對象，而不是使用默認構造函數創建。

std::shared_ptr<int> ptr_1 = make_shared<int>();
std::shared_ptr<int> ptr_2 (ptr_1);

另外不建議使用get()函數獲取 shared_ptr 關聯的原始指針，因爲如果在 shared_ptr 析構之前手動調用了delete函數，同樣會導致類似的錯誤。