C++ primer智能指針（HasPtr）實現

智能指針顯然是C++吸引人的地方之一，必須掌握。看了《C++primer》，裡面著重講了智能指針的實現方式。

書中說到：

    “HasPtr(注：就是自定義的智能指針)在其它方面的行為與普通指針一致。具體而言，復制對象時，副本和原對象將指向同一基礎對象。如果通過一個副本改變基礎對象，則通過另一個對象訪問的值也會改變。

      新的HasPtr類需要一個析構函數來刪除指針。但是，析構函數不能無條件的刪除指針。”

     條件就是引用計數。如果該對象被兩個指針所指，那麼刪除其中一個指針，並不會調用該指針的析構函數，因為此時還有另外一個指針指向該對象。看來，智能指針主要是預防不當的析構行為，防止出現懸垂指針。

 
[cpp]
class U_Ptr { 
    friend class HasPtr; 
    int *ip; 
    size_t use; 
    U_Ptr(int *p) : 
        ip(p), use(1) { 
        cout << "U_ptr constructor called !" << endl; 
    } 
    ~U_Ptr() { 
        delete ip; 
        cout << "U_ptr distructor called !" << endl; 
    } 
}; 
裡面有個變量use和指針ip: use記錄了*ip對象被多少個HasPtr對象所指。假設現在又兩個HasPtr對象p1,p2指向了U_Ptr，那麼現在我delete  p1，use變量將自減1，  U_Ptr不會析構，那麼U_Ptr指向的對象也不會析構，那麼p2仍然指向了原來的對象，而不會變成一個懸空指針。當delete p2的時候，use變量將自減1，為0。此時，U_Ptr對象進行析構，那麼U_Ptr指向的對象也進行析構，保證不會內存洩露。  

包含指針的類需要特別注意復制控制，原因是復制指針時只復制指針中的地址，而不會復制指針指向的對象。

大多數C++類用三種方法之一管理指針成員

    （1）不管指針成員。復制時只復制指針，不復制指針指向的對象。當其中一個指針把其指向的對象的空間釋放後，其它指針都成了懸浮指針。這是一種極端

   （2）當復制的時候，即復制指針，也復制指針指向的對象。這樣可能造成空間的浪費。因為指針指向的對象的復制不一定是必要的。

   （3）第三種就是一種折中的方式。利用一個輔助類來管理指針的復制。原來的類中有一個指針指向輔助類，輔助類的數據成員是一個計數器和一個指針（指向原來的）（此為本次智能指針實現方式）。

     其實，智能指針的引用計數類似於java的垃圾回收機制：java的垃圾的判定很簡答，如果一個對象沒有引用所指，那麼該對象為垃圾。系統就可以回收了

[cpp]
# include  
using namespace std; 
class U_Ptr { 
    friend class HasPtr; 
    int *ip; 
    size_t use; 
    U_Ptr(int *p) : 
        ip(p), use(1) { 
        cout << "U_ptr constructor called !" << endl; 
    } 
    ~U_Ptr() { 
        delete ip; 
        cout << "U_ptr distructor called !" << endl; 
    } 
}; 
class HasPtr { 
public: 
    HasPtr(int *p, int i) : 
        ptr(new U_Ptr(p)), val(i) { 
        cout << "HasPtr constructor called ! " << "use = " << ptr->use << endl; 
    } 
    HasPtr(const HasPtr& orig) : 
        ptr(orig.ptr), val(orig.val) { 
        ++ptr->use; 
        cout << "HasPtr copy constructor called ! " << "use = " << ptr->use 
                << endl; 
    } 
    HasPtr& operator=(const HasPtr&); 
    ~HasPtr() { 
        cout << "HasPtr distructor called ! " << "use = " << ptr->use << endl; 
        if (--ptr->use == 0) 
            delete ptr; 
    } 
    int *get_ptr() const { 
        return ptr->ip; 
    } 
    int get_int() const { 
        return val; 
    } 
    void set_ptr(int *p) const { 
        ptr->ip = p; 
    } 
    void set_int(int i) { 
        val = i; 
    } 
    int get_ptr_val() const { 
        return *ptr->ip; 
    } 
    void set_ptr_val(int i) { 
        *ptr->ip = i; 
    } 
private: 
    U_Ptr *ptr; 
    int val; 
}; 
HasPtr& HasPtr::operator =(const HasPtr &rhs) {     //注意，這裡賦值操作符在減少做操作數的使用計數之前使rhs的使用技術加1，從而防止自我賦值 
    ++rhs.ptr->use; 
    if (--ptr->use == 0) 
        delete ptr; 
    ptr = rhs.ptr; 
    val = rhs.val; 
    return *this; 
} 
int main() { 
    int *pi = new int(0); 
    HasPtr *hpa = new HasPtr(pi, 100); 
    HasPtr *hpb = new HasPtr(*hpa); 
    HasPtr *hpc = new HasPtr(*hpb); 
    HasPtr hpd = *hpa; 
 
    cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl; 
    hpc->set_ptr_val(10000); 
    cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl; 
    hpd.set_ptr_val(10); 
    cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl; 
    delete hpa; 
    delete hpb; 
    delete hpc; 
    cout << hpd.get_ptr_val() << endl; 
    return 0; 
}