C++智能指针详解(确定不怕面试官？别想了点进来好好看看吧)

智能指针

背景

内存管理是C++中的一个常见的错误和bug来源。在大部分情形中，这些bug来自动态分配内存和指针的使用：当多次释放动态分配的内存时，可能会导致内存损坏或者致命的运行时错误；当忘记释放动态分配的内存时，会导致内存泄露。所以，我们需要智能指针来帮助我们管理动态分配的内存。其来源于一个事实：栈比堆要安全的多，因为栈上的变量离开作用域后，会自动销毁并清理。智能指针结合了栈上变量的安全性和堆上变量的灵活性。

主要思想

将基本类型指针封装为类对象指针（这个类肯定是个模板，以适应不同基本类型的需求），并在析构函数里编写delete语句删除指针指向的内存空间

常用指针

auto_ptr

过早的return语句以及异常的抛出，ptr将得不到正确释放，从而出现内存泄露。归根到底，指针并没有一个内在机制来自动管理与释放。然后，你可能想到了类：类内部存储指针，然后在析构函数中销毁该指针。类可以实现资源的自动管理。其好处是，只要类局部变量（分配在栈上）超出其作用域（不论其是如何离开的），其析构函数一定会被执行，那么管理的内存也将一定得到销毁。基于这样的想法，我们实现了一个简单的智能指针类：

#include <stdio.h>
#include <iostream>
using namespace std;

template<typename T> //模板
//智能指针
class Auto_ptr1 {
   
public:
	Auto_ptr1(T* ptr = nullptr):m_ptr{
   ptr} {
   }
	virtual ~Auto_ptr1() {
   
		delete m_ptr;
	}

	T& operator*() {
    return *m_ptr; }
	T* operator->() {
    return m_ptr; }
private:
	T* m_ptr;
};
//测试class
class Resource {
   
public:
	Resource() {
    cout << "Resource acquired!" << endl; }
	virtual ~Resource() {
    cout << "Resource destoryed!" << endl; }
};

int main() {
   
	{
   
		Auto_ptr1<Resource> res1(new Resource);
	}
	cin.ignore(10);
	return 0;
}

看来这样的想法完全可以，我们将动态申请的资源交给一个类变量来保存，由于类变量在局部作用域，其离开后将会自动调用析构函数，然后释放内存。同时，不论其是如何离开作用域的，即使出现异常，析构函数一定会被执行，内存也一定得到释放，因为该类变量是保存在栈上的。
但是上面的实现却有致命的隐患，考虑下面的代码：

int main()
{
   
    {
   
        Auto_ptr1<Resource> res1(new Resource);
        Auto_ptr1<Resource> res2(res1);
    }

    cin.ignore(10);
    return 0;
}

看起来没有问题，但是执行起来，程序会崩溃。因为用res1初始化res2，调用的是默认复制构造函数，执行的是浅复制。所以，res2与res1内部保存是同一块内存，当销毁变量时，同一块内存将会被多次释放，程序当然会奔溃。
所以我们需要修改这个类，最好自己实现复制构造函数，同样地要自己实现赋值运算符重载。假如我们在这两个函数中，将指针所有权从一个对象转移到另外一个对象，那么上面的问题将迎刃而解。修改的智能指针类如下：

class Auto_ptr2
{
   
public:

    Auto_ptr2(T* ptr = nullptr) : m_ptr{
    ptr }{
   
    }

    virtual ~Auto_ptr2()
    {
   
        delete m_ptr;
    }
    // 拷贝构造，右值引用
    Auto_ptr2(Auto_ptr2& rhs)
    {
   
        m_ptr = rhs.m_ptr;
        rhs.m_ptr = nullptr;
    }

    Auto_ptr2& operator=(Auto_ptr2& rhs)
    {
   
        //检测自我赋值
        if (&rhs == this)
            return *this;

        //转移内存权
        delete m_ptr;
        m_ptr = rhs.m_ptr;
        rhs.m_ptr = nullptr;
        return *this;
    }

    T& operator*() {
    return *m_ptr; }
    T* operator->() {
    return m_ptr; }
    bool isNull() const {
    return m_ptr == nullptr; }
private:
    T* m_ptr;
};

测试一下吧？

#include <stdio.h>
#include <iostream>
using namespace std;
template<typename T>
class Auto_ptr2
{
   
public:

    Auto_ptr2(T* ptr = nullptr) : m_ptr{
    ptr }{
   
    }

    virtual ~Auto_ptr2()
    {
   
        delete m_ptr;
    }
    // 拷贝构造，右值引用
    Auto_ptr2(Auto_ptr2& rhs)
    {
   
        m_ptr = rhs.m_ptr;
        rhs.m_ptr = nullptr;
    }

    Auto_ptr2& operator=(Auto_ptr2& rhs)
    {
   
        //检测自我赋值
        if (&rhs == this)
            return *this;

        //转移内存权
        delete m_ptr;
        m_ptr = rhs.m_ptr;
        rhs.m_ptr = nullptr;
        return *this;
    }

    T& operator*() {
    return *m_ptr; }
    T* operator->() {
    return m_ptr; }
    bool isNull() const