释放智能指针 make_shared_C++智能指针

码字不易，欢迎给个赞！

---

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

引言

考虑下面一个函数：

void someFunction()
{
    
    Resource* ptr = new Resource; // Resource是一个类或者结构
    // 使用ptr处理
    // ...
    delete ptr;
}

代码很简单：申请了一份动态内存，使用之后释放了它。但是我们很容易会在函数结束前释放它。也许我们记得及时释放动态申请的内存，但是仍然有一些不可抗力导致内存无法得到释放，比如函数提前终止了。考虑下面的代码：

void someFunction()
{
    
    Resource* ptr = new Resource; // Resource是一个类或者结构

    int x;
    std::cout << "Enter an integer: ";
    std::cin >> x;

    if (x == 0)
        return;  // 函数终止，无法释放ptr
    if (x < 0)
        throw;   // 出现异常，函数终止，无法释放ptr
    // 使用ptr处理
    // ...
    delete ptr;
}

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

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 Resource
{
    
public:
    Resource() {
     cout << "Resource acquired!" << endl; }
    virtual ~Resource() {
     cout << "Resource destoryed!" << endl; }
};
int main()
{
    
    {
    
        Auto_ptr1<Resource> res(new Resource);
    }

    cin.ignore(10);
    return 0;
}

执行上面的程序，我们可以得到下面的输出：

Resource acquired
Resource destroyed

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

但是上面的实现却有致命的隐患，考虑下面的代码：

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

    cin.ignore(10);
    return 0;
}

看起来没有问题，但是执行起来，程序会崩溃。因为用res1初始化res2，调用的是默认复制构造函数，执行的是浅复制。所以，res2与res1内部保存是同一块内存，当销毁变量时，同一块内存将会被多次释放，程序当然会奔溃。同样地，下面的代码依然存在同样的问题：

void passByValue(Auto_ptr1<Resource> res)
{}
int main()
{
    
    {
    
        Auto_ptr1<Resource> res1(new Resource);
        passByValue(res1);
    }

    cin.ignore(10);
    return 0;
}

因为res1被浅复制到函数参数res中，函数执行后其内存会被释放，那么在销毁res1时，又会销毁已经释放的内存，程序崩溃。

所以我们需要修改这个类，最好自己实现复制构造函数，同样地要自己实现赋值运算符重载。假如我们在这两个函数中，将指针所有权从一个对象转移到另外一个对象，那么上面的问题将迎刃而解。修改的智能指针类如下：

template<typename T>
class Auto_ptr2
{
    
public:
    Auto_ptr2(T* ptr = nullptr) :
        m_ptr{
     ptr }
    {}