以下是引用humy在2012-8-23 18:00:04的发言：

class U_ptr
{
    friend class Hasptr;
    int*ip;
    size_t use;
     
    U_ptr(int * p):ip(p),use(1){}
    ~U_ptr(void){ delete ip;}
};
class U_ptr;
 
class Hasptr
{
public:
    //constructor
    Hasptr(int* p,int i):ptr(new U_ptr(p),val(0){}     //1.智能指针的计数类使用，只是在复制和赋值时起作用啊，如果不通过复制和赋值，只是通过定义时传的指针p值相同，那这个计数器没变，仍能产生悬垂指针的危险啊
    //copy
    Hasptr(const Hasptr& p):ptr(p.ptr),val(p.val){++ptr->use;}
    //assignment operator
    Hasptr& operator=(const Hasptr&);
    //destructor   
    ~Hasptr(void)
    {
        if(--ptr->use==0)
            delete ptr;
    }
    //get element
    int* get_ptr(){  return ptr->ip;}
    int get_int(){   return val;}
    // change the appropriate data nember
    void set_ptr(int * p){ ptr->ip=p; }   //2.这里修改了ip，那use不应该改一下吗？应该和其他ip值相同的其他ptr的use保持一致吗？同时原ip的ptr的use不应该减一吗？
    void set_int(int i){val=i;}
    //return or change the value pointed to  
    int get_ptr_val()const {return *ptr->ip;}
    void set_ptr_val(int i){ *ptr->ip=i;
 
private:
    U_ptr* ptr;
    int val;
}
 
3.书上说没使用计数时，析构函数用来删除指针成员，那撤销一个Hasptr时会删除其指针对象，其他由该对象复制创建的对象的指针成员将无法使用，因为  指针成员所指的对象已被撤销。
是不是这个意思：      不加析构函数时，编译器会调用一个合成析构函数，该合成的函数只会把指针所用的空间释放，而其所指对象的空间没有被释放；自己加的析构函数应为：~Hasptr(void)
    {
         
            delete ptr;
    }
而用delete时就把指针所指对象的空间也释放了？
“析构函数撤销复合类型”的复合类型是指？
4.a复制构造函数，b析构函数，c定义赋值操作符,三者只要有一个没定义，则如由对象Hasptr  A复制赋值而来的对像B，会在A被删除后，其基础的int对象无法访问，且没被撤销
按照2.的说法我能理解没有b会这样，可没a,b怎么也这样？
class TreeNode{
public:
   TreeNode():count(0){}
   TreeNode(const TreeNode&);
   ~TreeNode();
private:
   string value;
    int count;
    TreeNode l;
   TreeNode r;
}
   
5.上面是书上的一个例子，为什么operator=的定义？
谢谢