以下是對C++中智能指標的使用進行了詳細的分析介紹，需要的朋友可以參考下
1. 為什麼需要智能指標？
簡單的說，智能指標是為了實作類別似於Java中的記憶體回收機制。Java的 記憶體回收機制使程式員從繁雜的記憶體管理工作中徹底的解脫出來，在申請使用一塊記憶體地區之後，無需去關注應該何時何地釋放記憶體，Java將會自動協助回收。 但是出於效率和其他原因（可能C++設計者不屑於這種傻瓜氏的編程方式），C++本身並沒有這樣的功能，其繁雜且易出錯的記憶體管理也一直為廣大程式員所詬 病。
更進一步地說，智能指標的出現是為了滿足管理類中指標成員的需要。包含指標成員的類需要特別注意複製控制和賦值操作，原因是複製指標時只複製指標中的地址，而不會複製指標指向的對象。當類的執行個體在析構的時候，可能會導致垂懸指標問題。
管理類中指標成員的方法一般有兩種方式：一種是採用值型類，這種類是給指標成員提供值語義（value semantics），當複製該值型對象時，會得到一個不同的新副本。這種方式典型的應用是string類。另外一種方式就是智能指標，實現這種方式的指標所指向的對象是共用的。
2. 智能指標的實現概述
智能指標(smart pointer)的一種通用實現技術是使用引用計數(reference count)。智能指標類將一個計數器與類指向的對象相關聯，引用計數跟蹤該類有多少個對象共用同一指標。
每 次建立類的新對象時，初始化指標並將引用計數置為1；當對象作為另一對象的副本而建立時，拷貝建構函式拷貝指標並增加與之相應的引用計數；對一個對象進行 賦值時，賦值操作符減少左運算元所指對象的引用計數（如果引用計數為減至0，則刪除對象），並增加右運算元所指對象的引用計數；調用解構函式時，建構函式 減少引用計數（如果引用計數減至0，則刪除基礎對象）。
實現智能指標有兩種經典策略：一是引入輔助類，二是使用控制代碼類。
3. 實現方式1：引入輔助類
這種方式定義一個單獨的具體類（RefPtr）來封裝指標和相應的引用計數。
複製代碼 代碼如下:
class Point //基礎對象類
{
public:
Point(int xVal = 0, int yVal = 0):x(xVal),y(yVal) { }
int getX() const { return x; }
int getY() const { return y; }
void setX(int xVal) { x = xVal; }
void setY(int yVal) { y = yVal; }
private:
int x,y;
};
class RefPtr //輔助類
{ //該類成員存取權限全部為private，因為不想讓使用者直接使用該類
friend class SmartPtr; //定義智能指標類為友元，因為智能指標類需要直接操縱輔助類
RefPtr(Point *ptr):p(ptr), count(1) { }
~RefPtr() { delete p; }
int count; //引用計數
Point *p; //基礎對象指標
};
class SmartPtr //智能指標類
{
public:
SmartPtr(Point *ptr):rp(new RefPtr(ptr)) { } //建構函式
SmartPtr(const SmartPtr &sp):rp(sp.rp) { ++rp->count; } //複製建構函式
SmartPtr& operator=(const SmartPtr& rhs) { //重載賦值操作符
++rhs.rp->count; //首先將右運算元引用計數加1，
if(--rp->count == 0) //然後將引用計數減1，可以應對自賦值
delete rp;
rp = rhs.rp;
return *this;
}
~SmartPtr() { //解構函式
if(--rp->count == 0) //當引用計數減為0時，刪除輔助類對象指標，從而刪除基礎對象
delete rp;
}
private:
RefPtr *rp; //輔助類對象指標
};
int main()
{
Point *p1 = new Point(10, 8);
SmartPtr sp1(p1);
SmartPtr sp2(sp1);
Point *p2 = new Point(5, 5);
SmartPtr sp3(p2);
sp3 = sp1;
return 0;
}
使用該方式的記憶體結構圖如下：
4. 實現方式2：使用控制代碼類
為 了避免上面方案中每個使用指標的類自己去控制引用計數，可以用一個類把指標封裝起來。封裝好後，這個類對象可以出現在使用者類使用指標的任何地方，表現為一 個指標的行為。我們可以像指標一樣使用它，而不用擔心普通成員指標所帶來的問題，我們把這樣的類叫控制代碼類。在封裝控制代碼類時，需要申請一個動態分配的引用計 數空間，指標與引用計數分開儲存。實現樣本如下：
複製代碼 代碼如下:
class Point //基礎對象類
{
public:
Point(int xVal = 0, int yVal = 0):x(xVal),y(yVal) { }
int getX() const { return x; }
int getY() const { return y; }
void setX(int xVal) { x = xVal; }
void setY(int yVal) { y = yVal; }
public:
virtual Point* clone() const { //虛函數，為了實現讓控制代碼類在不知道對象的確切類型的情況下分配已知對象的新副本
return new Point(*this);
}
private:
int x,y;
};
class D3Point : public Point //衍生類別
{
public:
D3Point(int xVal, int yVal, int zVal):Point(xVal, yVal), z(zVal) { }
int getZ() const { return z; }
void setZ(int zVal) { z = zVal; }
public:
D3Point* clone() const { //虛函數，為了實現讓控制代碼類在不知道對象的確切類型的情況下分配已知對象的新副本
return new D3Point(*this);
}
private:
int z;
};
class SmartPtr
{
public:
SmartPtr(Point *ptr = 0):p(ptr), count(new int(1)) { } //建構函式
SmartPtr(Point &point):p(point.clone()), count(new int(1)) { } //建構函式
SmartPtr(const SmartPtr &sp):p(sp.p), count(sp.count) { ++*count; } //複製建構函式
SmartPtr& operator=(const SmartPtr &sp) { //重載賦值操作符
++*sp.count; //首先將右運算元引用計數加1，
decr_use(); //然後將引用計數減1，可以應對自賦值
p = sp.p;
count = sp.count;
return *this;
}
~SmartPtr() { //解構函式
decr_use();
}
public: //一般情況下不會實現這兩個操作符，因為我們不希望使用者直接操縱基礎對象指標
const Point* operator->() const {
if(p) return p;
else throw logic_error("Unbound Point");
}
const Point& operator*() const {
if(p) return *p;
else throw logic_error("Unbound Point");
}
private:
void decr_use() {
if(--*count == 0)
{
delete p;
delete count;
}
}
private:
Point *p; //基礎對象指標
int *count; //指向引用計數的指標
};
int main()
{
Point *p1 = new Point(10, 8);
SmartPtr sp1(p1);
SmartPtr sp2(sp1);
D3Point *p2 = new D3Point(5, 5, 0);
SmartPtr sp3(p2);
return 0;
}
使用該方式的記憶體結構圖如下：
