C++常规指针类(浅复制)，智能指针类(计数类)，值行类(深复制) 区别

和恶

三种方法：

·1.常见指针（浅复制）

严重缺点：造成野指针

2.智能指针（技术类）

避免野指针

3.值型类（深复制）

严重缺点：复制大量重复对象，当对象较大时，造成内存的浪费

1.常见指针：

class AHasPtr{


public:
	AHasPtr( int *p,int i):ptr(p),val(i){}
	
	int *get_ptr() const {return ptr;}
	int get_int(){  return val;}

	void set_ptr(int *p) {ptr = p;}
	void set_int(int i){val = i;}

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

2.值型类

class CHasPtr{


public:
	CHasPtr(const int &p,int i):ptr(new int(p)),val(i){}
	CHasPtr(const CHasPtr &orig):ptr(new int(*orig.ptr)),val(orig.val){}

	CHasPtr& operator = (const CHasPtr&);//复制操作符
	~CHasPtr(){delete ptr; }//析构函数

	int *get_ptr() 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_val()const {return *ptr;}
	void set_ptr_val(int val)const {*ptr = val;}
	
private:
	int val;
	int *ptr;
};
CHasPtr&CHasPtr::operator = (const CHasPtr &rhs)
{
	*ptr = *rhs.ptr;
	val = rhs.val;
	return *this;

}

3.智能指针（计数类）

class U_Ptr
{
public :
	int *ptr;
	int *ip;
	size_t use;//记录有多少个对象指向智能指针（计数等于0的时候把它删除）
	U_Ptr(int *p):ip(p),use(1){}
	~U_Ptr(){delete ip;}
};

class BHasPtr{


public:
	BHasPtr( int *p,int i):ptr(new U_Ptr(p)),val(i){}
	
	BHasPtr(const BHasPtr & orig):ptr(orig.ptr),val(orig.val)
	{
		++ptr->use;
	
	}

	BHasPtr& operator =(const BHasPtr&);

	~BHasPtr()
	{
	
		if(--ptr->use==0)
		{
			delete ptr;
		}
	}
	int *get_ptr() const {return ptr->ip;}
	int get_int(){  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;}
	int set_ptr_val(int val)const {*ptr->ip = val;}
	
private:
	int val;
	//int *ptr; 不可以使用普通指针了

	U_Ptr *ptr;
};

BHasPtr& BHasPtr::operator =(const BHasPtr& rhs)
{
	++rhs.ptr->use;
	if(--ptr->use ==0) delete ptr;
	ptr = rhs.ptr;
	val = rhs.val;

	return *this;
}

。。