shared_ptr是一種智慧指標資料結構，除了具有智慧指標的基本功能——自動管理資源釋放外，還有一個特徵就是"share",我理解所謂的“share”就是多個shared_ptr共同分享同一處資源，避免了資源的拷貝。比如，當執行拷貝建構函式操作時：

class X{...};

shared_ptr<X> px1(new X());
shared_ptr<X> px2(px1);

或是賦值操作時：

class X{...};

shared_ptr<X> px1(new X(...));
shared_ptr<X> px2(new X(...));
px2 = px1;
 

shared_ptr不進行資源的拷貝，而是將內部的指標指向相應的資源即可。以上例子中，px2並不會從px1中拷貝資源，而是將內部指標指向px1中的資源。

那麼px2或px1被銷燬時會發生什麼？會將其指向的內部資源同時銷燬嗎？不會。現在的資源是大家公用的，不能被隨意銷燬。shared_ptr是採用引用計數(reference counting)來控制資源的指向和銷燬。內部資源會伴有一個計數值count，count表示有多少個shared_ptr指向該資源，每當有一個新的shared_ptr指向該資源時，count值加1，當有一個指向該資源的shared_ptr銷燬時，count值減1，當count變為0時，證明所有指向該資源的shared_ptr已經銷燬，此時內部資源也被銷燬。

自己寫了一個簡單的shared_ptr模板類，如下：

template<class T>
class my_shared_ptr{
public:
	my_shared_ptr(T* pt){
		_pBlock = new ControlBlock(pt);
	}
	my_shared_ptr(const my_shared_ptr& rhs){
		_pBlock = rhs._pBlock;
		_pBlock->ref_count++;
	}
	~my_shared_ptr(){
		_pBlock->ref_count --;
		if(0 == _pBlock->ref_count)
			delete _pBlock;
	}
	my_shared_ptr& operator=(const my_shared_ptr& rhs){
		if(this == &rhs)
			return *this;

		_pBlock->ref_count --;
		if(0 == _pBlock->ref_count)
			delete _pBlock;

		_pBlock = rhs._pBlock;
		_pBlock->ref_count++;
	}

	T* get(){return _pBlock->_ptr;}
	T* operator->(){return _pBlock->_ptr;}
	void reset(T* pt){
		_pBlock->ref_count --;
		if(0 == _pBlock->ref_count)
			delete _pBlock;

		_pBlock = new ControlBlock(pt);
	}

private:
	struct ControlBlock{
		int ref_count;
		T* _ptr;
		ControlBlock(T* pt){
			_ptr = pt;
			ref_count = 1;
		}
		~ControlBlock(){
			delete _ptr;
		}
	};
	ControlBlock* _pBlock;
};
 

my_shared_ptr內部有一個ControlBlock管理內部資源，同時有一個計數值ref_count標記指向該內部資源的my_shared_ptr個數。在拷貝建構函式和賦值操作符中，都有：

_pBlock = rhs._pBlock;
_pBlock->ref_count++;

語句，這兩句表示當發生my_shared_ptr的拷貝時，不拷貝內部資源，而是將內部指標指向同樣的內部資源，並增加計數值。

在解構函式中可以看到如下語句：

_pBlock->ref_count --;
if(0 == _pBlock->ref_count)
	delete _pBlock;

表示內部資源不是隨意銷燬的，解構函式會減小計數值，當計數值變為0時，內部資源才會銷燬。
在賦值操作符函式中，首先進行自檢，其次釋放本身指向的內部資源，之後指向新的內部資源，並更新計數值。

測試程式如下：

#include "my_shared_ptr.h"
#include <iostream>
using namespace std;

class X{
public:
	X(int i):_val(i){
		cout << "X(" << _val << ") constructed." << endl;
	}
	~X(){
		cout << "X(" << _val << ") destructed." << endl;
	}
	void print(){
		cout << "X(" << _val << ")::print()." << endl;
	}
private:
	int _val;
};


int main(){

	my_shared_ptr<X> shared_px1(new X(10));
	my_shared_ptr<X> shared_px2(new X(20));

	shared_px1->print();
	shared_px2->print();

	shared_px2 = shared_px1;

	shared_px1->print();
	shared_px2->print();
}

執行結果如下：

X(10) constructed.
X(20) constructed.
X(10)::print().
X(20)::print().
X(20) destructed.
X(10)::print().
X(10)::print().
X(10) destructed.

可以看到，在執行賦值操作符函式後，shared_px2所指向的內部資源被銷燬, 因為X(20)被析構；之後shard_px2和shared_px1指向了同一個內部資源，因為都列印了X(10)::print(). 程式結束時，所有內部資源都被自動銷燬。