智能指针概念及工程意义

智能指针实质上是一种能自动释放堆空间的类对象，能避免内存泄露的问题。

实现原理

通过函数重载技术对->和*进行重载操作，使得类对象的操作和指针相同。

代码实现

#ifndef SMARTPOINTER_H
#define SMARTPOINTER_H

/**
 *原理:堆栈空间的区别，当使用的指针生成对象时，在堆空间生成对象，需自己释放空间，而智能指针是通过栈区生成对象，系统自动释放。
 *SmartPointer<type> obj = new type(); 没有指针，所以自动释放空间，type* p = new type() 在堆空间生成对象，不能自动释放空间
*/

namespace BYLib     //定义命名空间
{

template < typename T >   //模板操作，可以使指针使各种类型
class SmartPointer
{
    T* m_pointer;

public:
    SmartPointer(T* p = nullptr)
    {
        m_pointer = p;
    }

    SmartPointer(const SmartPointer<T>& obj)
    {
        m_pointer = obj.m_pointer;
        const_cast<SmartPointer<T>&>(obj).m_pointer = nullptr;
    }

    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 = nullptr;
        }

        return *this;
    }

    T& operator ->()
    {
        return *m_pointer;
    }

    bool isNULL()
    {
        return (m_pointer == nullptr);
    }

    T* operator *()
    {
        return m_pointer;
    }

    ~SmartPointer()
    {
        delete m_pointer;
    }
};

}

#endif // SMARTPOINTER_H

/*智能指针类的使用方式*/
#include <iostream>
#include "SmartPointer.h"

using namespace std;
using namespace BYLib;

class  Text
{
public:
     Text()
     {
         cout << "text()" << endl;
     }
     ~Text()
     {
         cout << "~text()" << endl;
     }
};

void test()
{
    SmartPointer<Text> p = new Text();
    SmartPointer<Text> p1 = p;

    cout << p.isNULL() << endl;
    cout << p1.isNULL() << endl;
}

int main()
{
    test();
    cout << "end" << endl;
    return 0;
}

运行结果

可以看出，我们的智能指针并没有手动释放，却调用了析构函数，说明了智能指针在生命周期结束时可以自动释放空间，不会造成内存泄露问题，并且，我们的这个智能指针类还多了一个功能，那就是每个堆空间地址只能由一个智能指针指向，并且在赋值过后，另一个指针会自动置空。

本章内容涉及到了析构函数的调用原理（在栈区定义的对象，也就是不用指针，如( SmartPointer p = new Text();
SmartPointer p1 = p;) //用对象来模拟指针操作，就是我们俗称的智能指针
生命周期结束后会自动调用析构函数，但是，在堆空间里定义的对象，如（Text* t = new Text() ）不会自动调用析构函数，需要用到（delete t）来手动析构。）