摘要：

智能指针：通过C++模板技术实现的一个类模拟指针的行为（如->、*）

1. 内存泄漏（臭名昭著的Bug）

（1）动态申请堆空间，用完后不归还（堆空间越来越少，的那个程序长时间运行，就会导致总堆空间内存没有了）

（2）C++语言中没有垃圾回收的机制

（3）指针无法控制所指堆空间的生命周期（指针是变量，有生命周期，即一个局部指针指向了堆空间之后，当该指针的生命周期结束后，这段堆空间的生命周期并没有结束，这就发生了泄漏）

2. 当代C++软件平台中的智能指针

（1）指针生命周期结束时主动释放堆空间

（2）一片堆空间最多只能由一个指针标识（一片堆空间最多只能由一个指针 可以避免多次释放对空间的问题，因为如果有两个指针同时指向同一块内存空间，内存空间有可能会被释放两次造成内存错误）

（3）杜绝指针运算和指针比较

3.智能指针的设计方案

（1）通过类模板描述指针的行为，能够定义不同类型的指针对象

（2）重载指针特征操作符（->和 *），利用对象模拟原生指针的行为

（3）智能指针的使用军规：只能用来指向堆空间中的单个对象（即不能指定一个数组对象的空间）或者变量

【编程实验】智能指针
Smartpointer.h

        #ifndef SMARTPOINTER_H
#define SMARTPOINTER_H
namespace DTLib
{
   template < typename T >

   class SmartPointer
  {
    protected:
               T* m_pointer;
    public:
           SmartPointer(T* p=NULL)
           {
                m_pointer=p;
           }

           //拷贝构造函数
           SmartPointer(const SmartPointer<T>& obj)
           {
               m_pointer=obj.m_pointer;
               const_cast<SmartPoint<T>&>(obj).m_pointer=NULL;//传入参数是const，需要去掉const只读属性此处了的，但是我们的智能指针设计需求第二步，开辟的堆空间，只能有一个指针标识，所以我想去掉obj类中的指针成员的指向，使用强制类型转化   obj是需要去掉const 不是obj.m_pointer
           }


           //重载赋值操作符
            SmartPointer<T>& operator=(const SmartPointer<T>& obj)
            {
                   if(this != &obj){//判断是不是自己赋值
                       delete m_pointer;//用释放那个原来的堆空间
                       m_pointer = obj.m_pointer;
                       //所有权转移，使得同一时刻只能由一个指针指向堆空间
                       const_cast<SmartPointer<T>&>(obj).m_pointer= NULL;
                   }
                   return *this;
              }


    //重载指针特征操作符
          T* operator->()
          {
             return m_pointer;
          }

          T&  operator* ()
          {
              return *m_pointer;
          }
     //增加功能函数几个
       bool isNuLL()
        {
           return   (m_pointer==NULL);
        }
       T* get()
       {
           return m_pointer;
       }

       //析构函数
       ~SmartPointer()
       {
           delete m_pointer;
       }
  };
}
#endif // SMARTPOINTER_H
    

接下来测试下

        #include <iostream>
#include "smartpointer.h"
using namespace std;
using namespace std;
using namespace DTLib;

class Test
{
public:
    Test()
    {
        cout <<"Test()" << endl;
    }

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

int main(int argc, char *argv[])
{


   SmartPointer<Test> sp=new Test();//sp指向的是一个栈空间上的对象，程序结束后，栈上的资源会被销毁，调用sp的析构函数，进而删除堆空间的对象的

/*    Test*  t=new Test();*/   不会调用析构函数，因为 程序结束后，只是将栈中指针变量t销毁，堆中的对象仍然存在，所以不会调用析构函数。 
                               //如果在析构函数加入了delete t;就销毁堆空间中的对象，会调用析构函数。
 
    SmartPointer<Test> nsp;

    nsp = sp;

    cout << sp.isNull() << endl;
    cout << nsp.isNull() << endl;

    return 0;
}








/*输出结果
Test()
1
0
~Test()
*/
    

4. 小结

（1）指针特征操作符（->和*）可以被重载

（2）重载指针特征符能够使用对象代替指针

（3）智能指针只能用于指向堆空间中的内存

（4）智能指针的意义在于最大程序的避免内存问题

原文：https://www.cnblogs.com/zhaobinyouth/p/9478911.html