#include<iostream>

 #include<string>

 using namespace std;

 class Test

 {

     int i;

 public:

     Test(int i)

     {

         this->i = i;

     }

     int value()

     {

         return i;

     }

     ~Test()

     {

     }

 };

 int main()

 {

     for (int i = ; i < ; i++)

     {

         Test* p = new Test(i); //P指向堆空间的对象

                                //指针是局部变量for()循环之后消失，但是指针开辟的空间没有进行释放  内存泄漏

                                //长时间运行会出现Bug

         cout << p->value() << endl;

     }

     return ;

 }

 #include<iostream>

 #include<string>

 using namespace std;

 class Test

 {

     int i;

 public:

     Test(int i)

     {

         cout <<"Test (int i)"<< endl;

         this->i = i;

     }

     int value()

     {

         return i;

     }

     ~Test()

     {

         cout << "~Test ()" << endl;

     }

 };

 //智能指针  本质是对象--------首先创建智能指针类

 class Pointer

 {

     Test* mp;              //指针mp指向对象Test，用于保存要被管理对象的指针

 public:

     //构造函数被堆空间上内存地址初始化

     Pointer(Test* p = NULL)   //指针被堆空间上的地址初始化---参数Test*指针

     {

         mp = p;

     }

     //重载->操作符

     Test* operator -> ()    //不能使用参数，所以也就只能定义一个重载函数

     {

         return mp;             //返回成员指针

     }

     //重载*操作符  

     Test& operator * ()    //不能使用参数，所以也就只能定义一个重载函数

     {

         return *mp;        //*作用指针意义：返回当前指针所指变量或对象

     }

     ~Pointer()

     {

         delete mp;     //智能指针被析构时，同时删除其所管理的Test类的对象,释放成员指针指向的堆空间

     }

 };

 int main()

 {

     for (int i = ; i < ; i++)

     {

         //    Test* p = new Test(i);   //那么就可以用类对象名代替指针     

         Pointer p = new Test(i);     //可以动态的将申请的空间释放

         cout << p->value() << endl;  //

     }

     return ;

 }

 #include<iostream>

 #include<string>

 //智能指针  本质是对象

 using namespace std;

 class Test

 {

     int i;

 public:

     Test(int i)

     {

         cout <<"Test (int i)"<< endl;

         this->i = i;

     }

     int value()

     {

         return i;

     }

     ~Test()

     {

         cout << "~Test (int i)" << endl;

     }

 };

 class Pointer

 {

     Test* mp;    //数据成员为指针

 public:

     Pointer(Test* p = NULL)    //构造函数被堆空间上内存地址初始化

     {

         mp = p;

     }

     // 实现一片堆空间最多只能由一个指针标识   杜绝多次释放

     //拷贝构造函数

     Pointer(const Pointer& obj)                                         //自定义深拷贝构造函数

     {

      //   delete mp;        //拷贝构造阶段，mP野指针不能删除---内存错误

         mp = obj.mp;      //当前对象的成员指针mp指向初始化对象的成员指针所对应的堆空间---两个指针指向一片内存空间

                           //初始化对象把他指向的堆空间完全交给当前对象-----------即保证只有一个智能指针指向同一片内存

         const_cast<Pointer&>(obj).mp = NULL;  //所有权的传递，自己置空  const_cast去除只读属性

     }

     //赋值操作符重载函数

     Pointer& operator=(const Pointer& obj)  // 1，返回值类型一定是引用Test&为了连续赋值   2，参数是const引用类型

     {

         //进行赋值操作

         if (this != &obj)     //3，赋值操作符不是自赋值a=a，要避免赋值，通过This判断，this指向当前对象的地址和参数地址不同才进行赋值操作

         {

             delete mp;

             mp = obj.mp;     //保证赋值操作时，只能由一个智能指针指向同一堆空间

             const_cast<Pointer&>(obj).mp = NULL;

         }

         return *this;     //4，返回当前对象地址

     }

     //重载指针特征操作符

     Test* operator -> ()

     {

         return mp;    //返回成员指针

     }

     Test& operator * ()

     {

         return *mp;    //返回当前指针所指变量或对象

     }

     bool isNull()     //判断当前智能指针是否为空

     {

         return(mp == NULL);

     }

     ~Pointer()

     {

         delete mp;

     }

 };

 int main()

 {

     Pointer p1 = new Test();  //定义智能指针P1

     cout << p1->value() << endl;   //

     Pointer p2 = p1;          //定义智能指针P2，用p1进行初始化，p1管理的堆空间转给P2

     //不能指针比较的指针运算

 //    p2++;

 //    if(p1==p2)         

     cout << p1.isNull() << endl;   //1空 p1指向NULL，不再指向原来的堆空间

     cout << p2->value() << endl;   //0   p2接管P1指向的堆空间------管理92行堆对象

 
　　　　//p2++;不重载++，因为每次只能一个智能指针指向堆空间，这种++操作没意义

  

       //p2智能指针生命期结束，会自动释放接管的堆空间

 return ;  }