【C++练习题】实现智能指针

两种创建类实例的方法

  

   

    

     

    
    

     

      Person p1(10); 		        //对象创建在栈空间，值引用，系统自动析构
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      Person * p1 = new Person(10);	//对象创建在堆空间，指针访问，需要程序员delete调用析构
     
    
   

    

     

    
    

     

      p1->showAge();
     
    
   

    

     

    
    

     

      delete p1;
     
    
  
 

那么，有没有一种让对象分配在堆内存空间，使用指针的方式访问，但又不用程序员手动delete堆空间的实现呢？？？

智能指针

定义：用来托管自定义类型的对象，让对象进行自动的释放。

功能：既能让对象分配在堆内存空间，使用指针的方式访问，又不用程序员手动delete堆空间(系统实现)。

分析：设计一个smartPointer类，smartPointer类的指针成员来访问管理我所要管理的对象。这样管理的对象可以分配在堆空间(使用new创建)，而smartPointer类的实例确是在栈上创建的，在smartPointer类的析构中实现管理对象的delete,这样就实现了系统自动delete对象了；进一步在smartPointer类重载 '*' '->'运算符，可以像指针一样访问我要管理的对象，为智能指针。

我的码云：https://gitee.com/hinzer/my-notes-of-C_plus/tree/master/step8/smartPointer

智能指针创建步骤

1.定义指针成员，用来管理目标对象；
2.构造函数中，初始化指针成员；
3.析构函数中delete处理目标对象；
4.分别实现'->' '*'运算符的重载；

代码实现

  

   

    

     

    
    

     

      #include<iostream>
     
    
   

    

     

    
    

     

      using namespace std;
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      class Person
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     

      public:
     
    
   

    

     

    
    

     
	Person(int age)
     
    
   

    

     

    
    

     

      	{
     
    
   

    

     

    
    

     
		this->m_Age = age;
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	void showAge()
     
    
   

    

     

    
    

     

      	{
     
    
   

    

     

    
    

     

      		cout << "年龄为：" << this->m_Age << endl;
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     

      	~Person()
     
    
   

    

     

    
    

     

      	{
     
    
   

    

     

    
    

     

      		cout << "Person的析构调用" << endl;
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	int m_Age;
     
    
   

    

     

    
    

     

      };
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      class smartPointer
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     

      public:
     
    
   

    

     

    
    

     
	smartPointer(Person * person)
     
    
   

    

     

    
    

     

      	{//2.person指针初始化
     
    
   

    

     

    
    

     
		this->person = person;
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	Person * operator->()
     
    
   

    

     

    
    

     

      	{//3.重载->让智能指针对象 想Person *p一样去使用
     
    
   

    

     

    
    

     
		return this->person;
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	
     
    
   

    

     

    
    

     

      	Person& operator*()
     
    
   

    

     

    
    

     

      	{//3.重载 * 
     
    
   

    

     

    
    

     
		
     
    
   

    

     

    
    

     
		return *this->person;
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      	~smartPointer()
     
    
   

    

     

    
    

     

      	{//2.释放目标对象所在的堆空间
     
    
   

    

     

    
    

     

      		cout << "智能指针析构了" << endl;
     
    
   

    

     

    
    

     
		if (this->person !=NULL)
     
    
   

    

     

    
    

     

      		{
     
    
   

    

     

    
    

     
			delete this->person;
     
    
   

    

     

    
    

     
			this->person = NULL;
     
    
   

    

     

    
    

     

      		}
     
    
   

    

     

    
    

     

      	}
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      private:
     
    
   

    

     

    
    

     

      	Person * person;	//1.创建指针成员(访问堆内存)
     
    
   

    

     

    
    

     

      };
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      void test01()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	//Person p1(10); //对象创建在栈空间，系统自动析构
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	//Person * p1 = new Person(10); //对象创建在堆空间，需要程序员delete调用析构
     
    
   

    

     

    
    

     
	//p1->showAge();
     
    
   

    

     

    
    

     
	//delete p1;
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	smartPointer sp(new Person(10)); //sp开辟到了栈上，自动释放
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
	//
     
    
   

    

     

    
    

     

      	sp->showAge(); 		// sp->->showAge(); 编译器优化了 写法
     
    
   

    

     

    
    

     

      	(*sp).showAge();
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      int main()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
	test01();
     
    
   

    

     

    
    

     

      }
     
    
  
 

编译运行

文章来源: blog.csdn.net，作者：hinzer，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/feit2417/article/details/93708690