本文共 5357 字，大约阅读时间需要 17 分钟。

智能指针就是一个类，对普通指针进行封装，使智能指针对象具有普通指针类型一样的操作。（智能指针是封装普通指针的一个类，声明的对象和指针有一样的操作） 复制对象时，副本和原对象都指向同一存储区域，如果通过一个副本改变其所指的值，则通过另一对象访问的值也会改变。所不同的是，智能指针能够对内存进行自动管理，避免出现悬垂指针等情况。

普通指针的悬垂问题：当有多个指针指向同一个基础对象时，如果某个指针delete了该基础对象，对这个指针来说他已经明确他所指的对象被释放了，所以不会再对所指的对象进行操作，但是对于其他的指针来说，他们并不知道这个对象已经被释放了，还会指向这个被释放掉的对象并随时准备对其进行操作，这就形成了悬垂指针，程序也会慢慢崩溃。

悬垂指针产生的原因：删除基础对象的指针不知道还有其他指针和他一起共享这个基础对象，所以他在不知道的情况下将基础对象删除，让和他一起共享这个被删除的基础对象的指针成为悬垂指针。

解决办法：添加一个引用计数，用来计数有多少个指针共享一个基础对象，当一个指针delete后，计数器减一，直到计数器为0，才释放该基础对象。

引用计数：允许有多个相同值的对象共享这个值的实现 目的：

1. 简化跟踪堆(C++中new出来的)中对象的过程。一个对象一旦通过new被分配出来，要记录谁拥有该对象，因为其所有者要负责对其delete。但是对象所有者可以有多个，且所有权能够被传递，这就使得内存跟踪变得困难。引用计数可以跟踪对象所有权，并能够自动销毁对象。
2. 节省内存，提高程序运行效率。如果很多对象拥有相同的值，那么为多个相同的值存储多个副本就会浪费空间，所以让左右对象共享同一个值的实现。

智能指针的实现：辅助类和句柄类

定义一个基础对象类Point类

class Point{
   public:	/*初始化成员变量：相当于Point(int xVal = 0, int yVal = 0) {this->x = xVal; this->y = yVal;}*/	Point(int xVal = 0, int yVal = 0) : x(xVal), y(yVal) {
   }	/*const修饰成员函数：1.该函数不能改变对象的成员变量。2.不能调用非const的成员函数，因为任何非const的成员函数会有	修改成员变量的企图。3.const的成员函数才能被被const类对象调用，因为const类对象只能调用const成员函数。4.const关键字	不能同时和static关键字使用。因为static关键字修饰静态成员函数，静态成员函数不含有this指针，即不能实例化，而const	成员函数必须具体到某一实例*/	int getX const 	{
   		return x;	}	int getY const	{
   		return y;	}	void setX(int xVal)	{
   		x = xVal;	}	void setY(int yVal)	{
   		y = yVal;	}prinvate:	int x;	int y;};

在创建智能指针之前，先创建一个辅助类。这个类的所有成员都是私有类型，因为他不能被普通用户所使用。为了只让智能指针使用，还需要把智能指针声明为辅助类的友元。这个辅助类含有两个数据成员：计数count和智能对象指针。即辅助类用以封装使用计数和基础对象指针。

class U_Ptr{
   private:	/*类友元：类作为友元需要注意，友元类和原始类之间的相互依赖关系，如果在友元类中定义的函数访问原始类的私有变量，那么需要在	友元类定义文件中包含原始类定义的头文件。但是在原始类的定义中（包含友元类声明的类），不需要包含友元类的头文件。 另外，	不需要在类定义前去声明友元类，因为友元类的声明自身就是一种声明。*/	friend class SmartPtr;  //智能指针声明为辅助类的友元，因为智能指针类需要直接操纵辅助类	U_Ptr(Point *ptr) :p(ptr),count(1) {
   }  //构造函数的参数为基础对象的指针	~U_Ptr() {
   delete p;}	    //两个数据成员：计数count，基础指针对象    int count;    Point *p;};

引用计数是实现智能指针的一种通用方法。智能指针将一个计数器与类指向的对象相关联，引用计数器跟踪共有多少个类对象共享同一指针。具体做法：

• 当创建类的新对象时，初始化指针，并将引用计数设置为1
• 当对象作为另一个对象的副本时，复制构造函数，复制副本指针，并增加与指针相应的应用计数(加1)
• 使用赋值操作符对一个对象进行赋值时，处理复杂一点：先使左操作数的指针的引用计数减1 （为何减1：因为指针已经指向别的地方），如果减1后引用计数为0，则释放指针所指对象内存。然后增加右操作数所指对象的引用计数（为何加1：因为此时做操作数指向对象即右操作数指向对象）
• 析构函数：调用析构函数时，析构函数先使引用计数减1，如果减至0则delete对象。

做好前面的准备后，可以根据计数引用实现关键点写智能指针：

class SmartPtr{
   public:	SmartPtr(Point *ptr) :rp(new U_Ptr(ptr))  {
   }	SmartPtr(const SmartPtr &sp) :rp(sp.rp) {
   ++rp->count;}	SmartPtr& operator=(const SmartPtr& rhs)	{
   		++rhs.rp->count;		if (--rp->count == 0)		{
   			delete rp;		}		rp =  rhs.rp;		return *this;	}	~SmartPtr()	{
   		if (--rp->count == 0)		{
   			delete rp;		}		else		{
   			cout << "还有" << rp->count << "个指针指向基础对象" <

到这里，智能指针就完成了。下面看看如何使用。

int main(){
   	//定义一个基础对象类指针	Point *pa = new Point(10, 20);	//定义三个智能指针对象，对象都指向基础类对象pa	//使用花括号控制三个智能指针的生命周期，观察计数的变化	{
   		SmartPtr sptr1(pa);  //此时计数count=1		{
   			SmartPtr sptr2(sptr1);  //调用复制构造函数，此时计数count=3			{
   				SmartPtr sptr3 = sptr1;  //调用复制操作符，此时计数count=3			}  //此时count=2		}  //此时count=1	}  //此时count=0,pa对象被delete了	cout << pa->getX() << endl;  //pa对象已经被delete了，此时获取不到原来的值，得到的是一个随机值	system("pause");	return 0;}

智能指针的改进：

（一）SmartPtr类虽然被称为智能指针，但是目前并不能像真正的指针那样有->,*等操作符，所以，我们需要为他重载这些操作符。

{
   public:	SmartPtr(Point *ptr) :rp(new U_Ptr(ptr)) {
   }	SmartPtr(const SmartPtr &sp) :rp(sp.rp) {
    ++rp->count; }	SmartPtr &operator=(const SmartPtr &rhs)	{
   		++rhs.rp->count;		if (--rp->count == 0)		{
   			delete rp;		}		rp = rhs.rp;		return *this;	}	~SmartPtr()	{
   		if (--rp->count == 0)		{
   			delete rp;		}		else		{
   			cout << "还有" << rp->count << "个指针指向基础对象" << endl;		}	}		Point &operator *()  //重载*操作符	{
   		return *(rp->p);	}	POint *operator ->()  //重载->操作符	{
   		return rp->p;	}	private:	U_Ptr *rp;};

使用：

Point *pa = new Point(10, 20);SmartPtr sptr1(pa);//像指针般使用cout << sptr1->getX();

(二)为了使智能指针适用于更多的基础对象类，把智能指针类通过模板来实现。

//模板类作为友元时要先有声明template 
   
    class SmartPtr;template 
    
     class U_Ptr  //辅助类{
   private:	//该类成员访问权限全部为private，因为不想让用户直接使用该类	friend class SmartPtr
     
      ;  //定义智能指针类为友元，因为智能指针类需要直接操纵辅助类	//构造函数的参数为基础对象的指针	U_Ptr(T *ptr) :p(ptr), count(1) {
   }	//析构函数	~U_Ptr() {
   delete p;}	//引用计数	int count;	//基础对象指针	T *p;	};template 
      
       class SmartPtr  //智能指针类{
   public:	//构造函数	SmartPtr(T *ptr) :rp(new U_Ptr
       
        (ptr)) {
   }	//复制构造函数	SmartPtr(const SmartPtr
        
          &sp) :rp(sp.rp) { ++rp->count; } //重载赋值操作符 SmartPtr &operator=(const SmartPtr
         
           &rhs) { ++rhs.rp->count; //首先将右操作数引用计数加1 if (--rp->count == 0) //然后将引用计数减1 { delete rp; } re = rhs.rp; return *this; } //重载*操作符 T &operator *() { return *(rp->p); } //重载->操作符 T *operator ->() { return rp->p; } //析构函数 ~SmartPtr() { //当引用计数为0时，删除辅助类对象指针，从而删除基础对象 if (--rp->count == 0) { delete rp; } else { cout << "还有" << rp->count << "个指针指向基础对象" << endl; } }private: U_Ptr
          
            *rp; //辅助类对象指针};
          
         
        
       
      
     
    
   

使用该智能指针类对象来共享其他类型的基础对象，比如int:

int main(){
   	int *i = new int(2);	{
   		SmartPtr
   
     ptr1(i);		{
   			SmartPtr
    
      ptr2(ptr1);			{
   				SmartPtr
     
       ptr3 = ptr2;				cout << *ptr1 << endl;				*ptr1 = 20;				cout << *ptr2 << endl;			}		}	}	system("pause");	return 0;}
     
    
   

智能指针：实际指行为类似于指针的类对象 ，它的一种通用实现方法是采用引用计数的方法。

1.智能指针将一个计数器与类指向的对象相关联，引用计数跟踪共有多少个类对象共享同一指针。 2.每次创建类的新对象时，初始化指针并将引用计数置为1； 3.当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数； 4.对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；这是因为左侧的指针指向了右侧指针所指向的对象，因此右指针所指向的对象的引用计数+1； 5.调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。 6.实现智能指针有两种经典策略：一是引入辅助类，二是使用句柄类。

转载地址：http://zdqzi.baihongyu.com/