智能指针

为什么引用智能指针。为了阐明所涉及的问题，我们将实现一个简单类。该类包含一个int值和一个指针

using names std;

class HasPtr
{
public:
	HasPtr(int *p,int i):ptr(p),val(i){};
public:
	int *ger_ptr()const{return ptr;}
	int get_val()const {return val;}
	void set_ptr(int *p){ptr=p;}
	void set_val(int i){val=i;}

	int get_ptr_val()const{return *ptr;}
	void set_str_val(int val){*ptr=val;}
private:
	int *ptr;
	int val;
};

因为HasPtr类没有定义复制构造函数，所以复制一个HasPtr对象将复制两个成员：

int obj=0;
HasPtr Ptr1(&obj,42);
HasPtr Ptr2(Ptr1);

复制之后，ptr1和ptr2中的指针指向同一个对象，且两个对象中的int相同，但是因为指针的值不同于它所指向对象的值，这两个成员的行为看来非常不同，复制之后，int的值是清楚的和独立的，而指针则纠缠在一起。

这样就可能发生危险，可能会出现悬挂指针，例如：

int *ip =new int(42);
HasPtr ptr(ip,10);
delete ip;
ptr.set_ptr_val(10);//此时ptr所指向的对象已经释放。将出现灾难性的错误，然而，没有办法得知对象已经不存在了。

因此我们需要重写新的HasPtr类，新的类需要一个析构函数来删除指针，但是析构函数不能无条件的删除指针，如果俩个对象指向同一基础对象，那么，在两个对象都撤销之前，我们并不希望删除基础对象，为了编写析构函数，需要知道这个hasptr对象是否为指向给定对象的最后一个。

定义只能指针的通用技术室采用一个使用计数，只能指针将一个计数器与类指向的对象相关联，使用计数跟踪该类有多少个对像共享同一指针，使用计数为0时，是哪出对戏那个，使用计数有时也称引用计数。

每次创建类的新对象时，初始化指针并将使用计数置为1.当对象作为另一个对象的副本而创建时，复制构造函数复制指针，并增加与之相应的使用计数的值，对一个对象进行赋值时，赋值操作符减少左操作数所指向对象使用计数的值，并增加有操作数使用计数的的值。

class U_Ptr
{
    friend class HasPtr;
	int *ip;
	size_t use;
	U_Ptr(int *p):ip(p),use(1){}
	~U_Ptr(){delete ip;}
};

这个类的所有成员均为private。我们不希望普通用户使用u_Ptr类，所以他没有任何public成员，将HasPtr类设置为友元。使其成员可以访问U_Ptr的成员。

class HasPtr
{
public:
	HasPtr(int *p,int i):ptr(new U_Ptr(p)),val(i){}
	HasPtr(const HasPtr &orig):ptr(orig.ptr),val(orig.val){++orig->use;}
	HasPtr& operator =(const HasPtr&);
	~HasPtr(){if(--ptr->use)delete ptr;}
private:
	U_Ptr *ptr;
	int val;
};