[C++]智能指针

详情见文：
http://blog.csdn.net/hackbuteer1/article/details/7561235

#include <iostream>
using namespace std;
class U_ptr {
private:
    friend class HasPtr;
    int *ip;
    size_t use;
    U_ptr(int *p) : ip(p), use(1) {};
    ~U_ptr() {
        delete ip;
    }
};

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 &orig);
    ~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) {
        ptr->ip = p;
    }
    void set_int(int i) {
        val = i;
    }
    int get_ptr_val() const {
        return *ptr->ip;
    }
    void set_ptr_val(int i) const {
        *ptr->ip = i;
    }

private:
    U_ptr *ptr;
    int val;
};

HasPtr& HasPtr::operator=(const HasPtr &orig) {
    ++orig.ptr->use;
    if (--ptr->use == 0) {
        delete ptr;
    }
    ptr = orig.ptr;
    val = orig.val;
    return *this;
}

int main(void)
{
    int *pi = new int(42);
    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;
}

// 定义值型类
#include <iostream>
using namespace std;
class Has_Ptr {
public:
    Has_Ptr(const int &p, int i) : ptr(new int(p)), val(i) {}
    Has_Ptr(const Has_Ptr &orig) :
    ptr(new int (*orig.ptr)), val(orig.val) {}
    Has_Ptr& operator=(const Has_Ptr&);
    ~Has_Ptr() {
        delete ptr;
    }
    int get_ptr_val() const {
        return *ptr;
    }
    int get_int() const {
        return val;
    }
    void set_ptr(int *p) {
        ptr = p;
    }
    void set_int(int i) {
        val = i;
    }
    int *get_ptr() const {
        return ptr;
    }
    void set_ptr_val(int p) const {
        *ptr = p;
    }
private:
    int *ptr;
    int val;
};
Has_Ptr& Has_Ptr::operator=(const Has_Ptr &orig) {
    *ptr = *orig.ptr;
    val = orig.val;
    return *this;
}

int main() {
    int *p = new int(42);
    Has_Ptr hpd(*p, 10);
    Has_Ptr hpa(hpd);
    int *h = new int(20);
    Has_Ptr hpc(*h, 29);
    hpd = hpc;
    cout << hpa.get_int() << endl;
    cout << hpd.get_ptr_val() << endl;
    return 0;
}