C++：智能指针 sp 之手动实现智能指针

自己实现智能指针

1. 类对象指针未手动delete导致的内存泄漏

   
   #include <iostream>
   #include <string.h>
   #include <unistd.h>
   
   using namespace std;
   
   class Person {
        
   public:
       Person() {
        
           cout <<"Pserson()"<<endl;
       }
   
       ~Person()
       {
        
           cout << "~Person()"<<endl;
       }
   
       void printInfo(void)
       {
        
           cout<<"just a test function"<<endl;
       }
   };
   
   void test_func(void)
   {
        
       Person *p = new Person();
       p->printInfo();
       //(1)此处没有用delete p来销毁对象，导致内存泄漏
   }
   
   int main(int argc, char **argv)
   {
            
       int i;
   
       for (i = 0; i < 2; i++)
           test_func();
       //(2)其他任务...（此时上面的test_func存在内存泄露）
   
       return 0;
   }
   

   上述main函数中(2)执行其他任务时，上方test_func调用内部使用指针p来管理new出的对象，由于对象使用结束后未使用delete p销毁对象，导致函数test_func调用结束后Person对象内存依然存在从而出现内存泄漏，值得一提的是当main函数结束时那部分对象内存也还是存在，除非设备下电关机。

   改进方法之一，是test_func中直接声明类成员局部变量（创建对象），使用非指针的方式进行管理。
    

2. 局部变量保存类对象，变量生命周期结束时自动销毁

   
   void test_func(void)
   {
        
       //Person *p = new Person();
       Person per;
       per.printInfo();
   }
   
   int main(int argc, char **argv)
   {
            
       int i;
       for (i = 0; i < 2; i++)
           test_func();
   
       return 0;
   }
   

   众所周知，对于局部变量，当函数调用返回时函数内部的局部变量生命周期结束，此时编译器会自动调用析构函数来销毁对象。也就是说，当test_func函数调用结束时，对象per被自动销毁，避免了内存泄漏。

   但是你无法阻止他人使用指针，我们可以将局部变量和指针结合来解决指针导致的内存泄漏问题。
    

3. 局部变量和类指针结合解决类对象未手动delete导致的内存泄漏

   class sp {
        
   private:
       Person *p; //(1)目标类指针
   
   public:
       sp() : p(0) {
        }
       
       sp(Person *other) //(2)一个传入目标类指针参数的构造函数
       {
        
           cout<<"sp(Person *other)"<<endl;
           p = other;
       }
   
       ~sp()
       {
        
           cout<<"~sp()"<<endl;
           if (p) //(3) 析构函数中销毁目标类对象
               delete p;
       }
   
       Person *operator->() //(4) 重载->运算符，这样便可以访问目标类Person的成员了。
       {
        
           return p;
       }
   };
   
   void test_func(void)
   {
        
       #if 1
       /* calm: 
        *  关键：这会导致调用构造函数 sp(Person *other)
        *  这里 new Person() 创建的对象作为参数传给类sp的构造函数 sp(Person *other)。
        * 由于s是test_func函数内部局部变量，在函数调用结束返回时 s 会被自动销毁，
        * 销毁时便会调用析构函数 ~sp()将p指向的new Person()创建的对象销毁掉，
        * 从而达到避免内存泄漏的目的。
        */
       sp s = new Person();