一.智能指针的使用与设计思想

1.智能指针作用引入

在上节讲到异常时，有这么一段代码：

•我们提到，由于异常特殊的查询代码块机制，在发生异常进行捕获时可能会跳过一些重要的析构逻辑从而导致内存泄漏。

•例如这里的创建的数组array1，array2，当使用new分配内存时（如new int[10]），如果系统内存不足或分配失败，会抛出std::bad_alloc异常。在代码中，如果array1分配成功，但array2分配失败（抛异常），程序流会立即中断，跳过后续所有代码。此时，array1已分配的内存无法被自动释放，导致内存泄漏。

•由此往来，如果我们创建更多的数组，就需要更多单独为处理每个数组的new异常写try-catch，这种管理方式十分繁琐。

•于是我们引入一种特殊的机制来帮我们管理这些对象和资源，它就是——智能指针。

 int* array1 = new int[10];
 int* array2 = new int[10]; // 抛异常
 //初始化出array2，就需要释放array1
 //如果初始化出更多数组，就需要释放array1和array2...
 //释放逻辑太长，代码太长，不好管理
 try
 {
     int len, time;
     cin >> len >> time;
     cout << Divide(len, time) << endl;
 } 
 catch(...)
 {
     cout << "delete []" << array1 << endl;
     cout << "delete []" << array2 << endl;
     delete[] array1;
     delete[] array2;
     throw; // 异常重新抛出，捕获到什么抛出什么
 } 
 // ...
 cout << "delete []" << array1 << endl;
 delete[] array1;
 cout << "delete []" << array2 << endl;
 delete[] array2;

2.RAII与智能指针的设计思想

•RAII是Resource Acquisition Is Initialization(资源获取即初始化)的缩写，他是⼀种管理资源的类的设计思想，本质是⼀种利⽤对象⽣命周期来管理获取到的动态资源，避免资源泄漏，这⾥的资源可以是内存、⽂件指针、⽹络连接、互斥锁等等。

•智能指针本质是一个封装的类，我们利用类对象出作用域自动析构这个特性来对资源进行管理。既然叫“智能指针”，我们可以猜到它是以这种类对象的行为，封装运算符重载达到模仿指针行为的封装的类，有一点类似我们之前讲到的容器的迭代器。

template<class T>
class SmartPtr
{
    public :
    // RAII
    SmartPtr(T* ptr)
        : _ptr(ptr)
    {}
    ~SmartPtr()
    {
        cout << "delete[] " << _ptr << endl;
        delete[] _ptr;
    } 
    // 重载运算符，模拟指针的⾏为，⽅便访问资源
    T& operator*()
    {
        return *_ptr;
    } 
    T* operator->()
    {
        return _ptr;
    } 
    T& operator[](size_t i)
    {
        return _ptr[i];
    }
private:
    T* _ptr;
};
double Divide(int a, int b)
{
    // 当b == 0时抛出异常
    if (b == 0)
    {
        throw "Divide by zero condition!";
    } 
    else
    {
   return(double)a / (double)b;
    }
} 
void Func()
    {
        // 这⾥使⽤RAII的智能指针类管理new出来的数组以后，程序简单多了
        SmartPtr<int> sp1 = new int[10];
        SmartPtr<int> sp2 = new int[10];
        for (size_t i = 0; i < 10; i++)
        {
            sp1[i] = sp2[i] = i;
        } 
        int len, time;
        cin >> len >> time;
        cout << Divide(len, time) << endl;
    }

•上面的代码展示了最简单的智能指针设计逻辑以及使用。观察Func函数，我们这里同样new了两个数组sp1，sp2，只不过我们把它们的资源交给智能指针去管理，想想看：如果sp2在new过程中抛异常，我们由上节异常的知识得知，这会产生栈展开的行为以寻找匹配的异常处理块，此时当前的栈帧就会被提前销毁。不过跟之前不同的是，sp1由智能指针管理，出栈帧自动销毁，这样就避免了内存泄漏。

二.C++标准库的智能指针

1.智能指针一览

• C++标准库中的智能指针都在<memory>这个头⽂件下，这个头文件下有各种智能指针，他们之间的差异在于对拷贝和赋值的处理不同，接下来挨个介绍。

 • auto_ptr是C++98时设计出来的智能指针，他的特点是拷⻉时把被拷⻉对象的资源的管理权转移给拷⻉对象，这是⼀个⾮常糟糕的设计，因为他会产生拷⻉对象悬空，访问报错的问题，C++11设计出新的智能指针后，强烈建议不要使⽤auto_ptr。

struct Date
{
    int _year;
    int _month;
    int _day;

    Date(int year = 1, int month = 1, int day = 1)
        :_year(year)
        , _month(month)
        , _day(day)
    {}

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


auto_ptr<Date> ap1(new Date);
// 拷⻉时，管理权限转移，被拷⻉对象ap1悬空
auto_ptr<Date> ap2(ap1);
// 空指针访问，ap1对象已经悬空
//ap1->_year++;

• unique_ptr是C++11设计出来的智能指针，他的名字翻译出来是唯⼀指针，他的特点的不⽀持拷⻉，只⽀持移动。如果不需要拷⻉的场景就⾮常建议使⽤他。原理也较为简单，直接用default把它的拷贝构造和赋值构造全ban掉即可。

unique_ptr<Date> up1(new Date);
// 不⽀持拷⻉
//unique_ptr<Date> up2(up1);
// ⽀持移动，但是移动后up1也悬空，所以使⽤移动要谨慎
unique_ptr<Date> up3(move(up1));

• shared_ptr是C++11设计出来的智能指针，他的名字翻译出来是共享指针，他的特点是⽀持拷⻉，也⽀持移动。如果需要拷⻉的场景就需要使⽤他了。具体怎么实现“共享”呢？底层是⽤引⽤计数的⽅式实现的。

shared_ptr<Date> sp1(new Date);
// ⽀持拷⻉
shared_ptr<Date> sp2(sp1);
shared_ptr<Date> sp3(sp2);
cout << sp1.use_count() << endl;
sp1->_year++;
cout << sp1->_year << endl;
cout << sp2->_year << endl;
cout << sp3->_year << endl;
// ⽀持移动，但是移动后sp1也悬空，所以使⽤移动要谨慎
shared_ptr<Date> sp4(move(sp1));

• weak_ptr是C++11设计出来的智能指针，他的名字翻译出来是弱指针，他完全不同于上⾯的智能指针，他不⽀持RAII，也就意味着不能⽤它直接管理资源，weak_ptr的产⽣本质是要解决shared_ptr的⼀个循环引⽤导致内存泄漏的问题。

• 智能指针析构时默认是进⾏delete释放资源，这也就意味着如果不是new出来的资源，交给智能指针管理，析构时就会崩溃。智能指针⽀持在构造时给⼀个删除器，所谓删除器本质就是⼀个可调⽤对象，这个可调⽤对象中实现你想要的释放资源的⽅式，当构造智能指针时，给了定制的删除器，在智能指针析构时就会调⽤删除器去释放资源。因为new[]经常使⽤，所以为了简洁⼀点，

unique_ptr和shared_ptr都特化了⼀份[]的版本，使⽤时	unique_ptr<Date[]> up1(new
Date[5]);shared_ptr<Date[]> sp1(new Date[5]);	就可以管理new []的资源。

•

template <class T, class... Args> shared_ptr<T> make_shared

(Args&&... args);

• shared_ptr 除了⽀持⽤指向资源的指针构造，还⽀持 make_shared ⽤初始化资源对象的值直接构造。

• shared_ptr 和 unique_ptr 都⽀持了operator bool的类型转换，如果智能指针对象是⼀个空对象没有管理资源，则返回false，否则返回true，意味着我们可以直接把智能指针对象给if判断是否为空。

• shared_ptr 和 unique_ptr 都得构造函数都使⽤explicit 修饰，防⽌普通指针隐式类型转换成智能指针对象。

2.定制删除器

定制删除器允许你告诉智能指针：“当你管理这个资源时，请不要用 delete，而是用我提供的这个特定函数来释放它。”

默认情况下：

• std::unique_ptr<int> 在析构时使用 delete。

• std::unique_ptr<int[]> 在析构时使用 delete[]。

• std::shared_ptr 的默认删除器也是 delete。

但现实世界中，资源远不止是用 new 分配的内存。我们还有很多其他的资源获取方式，它们需要配对的释放方式：

• 用 malloc() 分配的内存，需要用 free() 释放。

• 使用 C API fopen() 打开的文件，需要用 fclose() 关闭。

• 使用 Win32 API CreateFile() 创建的内核对象，需要用 CloseHandle() 关闭。

• 使用 OpenGL 函数 glGenBuffers() 生成的缓冲区，需要用 glDeleteBuffers() 删除。

• 以及其他任何“获取-释放”配对的操作。

class Fclose
{
public:
    void operator()(FILE* ptr)
    {
        cout << "fclose:" << ptr << endl;
        fclose(ptr);
    }
};

template<class T>
void DeleteArrayFunc(T* ptr)
{
    delete[] ptr;
}

int main()
{
    bit::shared_ptr<Date> sp1(new Date);

    // 定制删除器 都可以，相对建议lambda
    bit::shared_ptr<Date> sp3(new Date[10], [](Date* ptr) {delete[] ptr; });
}

int main()
{
    std::shared_ptr<Date> sp1(new Date);
    std::shared_ptr<Date[]> sp2(new Date[10]);

    // 定制删除器 都可以，相对建议lambda
    std::shared_ptr<Date> sp3(new Date[10], [](Date* ptr) {delete[] ptr; });
    std::shared_ptr<Date> sp4(new Date[5], DeleteArrayFunc<Date>);

    std::shared_ptr<FILE> sp5(fopen("Test.cpp", "r"), Fclose());
    shared_ptr<FILE> sp6(fopen("Test.cpp", "r"), [](FILE* ptr) {
        //cout << "fclose:" << ptr << endl;
        fclose(ptr);
        });

    std::unique_ptr<Date> up1(new Date);
    std::unique_ptr<Date[]> up2(new Date[10]);
    // 定制删除器 建议仿函数
    std::unique_ptr<FILE, Fclose> up3(fopen("Test.cpp", "r"));

    auto fcloseFunc = [](FILE* ptr) {fclose(ptr); };
    std::unique_ptr<FILE, decltype(fcloseFunc)> up4(fopen("Test.cpp", "r"), fcloseFunc);

    return 0;
}

可以看到这里定制删除器的思想跟我们在排序时传入的仿函数思想是差不多的.

3.operator bool

智能指针重载bool用于查看当前的智能指针是否为空(是否管理对象)，如果为空则为false，如果有对象则为true

#include <memory>
#include <iostream>

int main() {
    std::unique_ptr<int> ptr1(new int(10));
    std::unique_ptr<int> ptr2; // 空指针

    if (ptr1) {
        std::cout << "ptr1 is not null" << std::endl;
    } else {
        std::cout << "ptr1 is null" << std::endl;
    }

    if (ptr2) {
        std::cout << "ptr2 is not null" << std::endl;
    } else {
        std::cout << "ptr2 is null" << std::endl;
    }

    // 同样适用于shared_ptr
    std::shared_ptr<int> ptr3 = std::make_shared<int>(20);
    if (ptr3) {
        std::cout << "ptr3 is not null, value: " << *ptr3 << std::endl;
    }

    return 0;
}

注意点：

operator bool是explicit的（C++11起），这意味着它不会意外地转换成其他类型（比如整数）。因此，以下代码是无效的：

std::unique_ptr<int> ptr(new int(10));
int x = ptr; // 错误：不能将unique_ptr转换为int
int y = static_cast<bool>(ptr); // 正确：显式转换为bool，然后可以用于赋值给int（true转为1，false转为0）

1. 在条件语句中（如if、while、for）或逻辑运算符中（&&、||、!），编译器会允许使用explicit的operator bool，因为这些上下文需要布尔值，会进行隐式转换。

2. 使用operator bool比直接调用get()与nullptr比较更简洁：

if (ptr) { ... }         // 好
if (ptr != nullptr) { ... } // 也可以，但冗长
if (ptr.get()) { ... }   // 也可以，但不如直接使用ptr直观

实现原理：

explicit operator bool() const noexcept {
    return get() != nullptr;
}

4.智能指针的原理

1.auto与unique

auto和unique的实现原理比较简单，这里直接看代码即可

template<class T>
class auto_ptr
{
    public :
    auto_ptr(T* ptr)
        : _ptr(ptr)
    {}
    auto_ptr(auto_ptr<T>& sp)
        :_ptr(sp._ptr)
    {
        // 管理权转移
        sp._ptr = nullptr;
    } 
    auto_ptr<T>& operator=(auto_ptr<T>& ap)
    {
        // 检测是否为⾃⼰给⾃⼰赋值
            if (this != &ap)
            {
                // 释放当前对象中资源
                if (_ptr)
                    delete _ptr;
                // 转移ap中资源到当前对象中
                _ptr = ap._ptr;
                ap._ptr = NULL;
            } 
        return* this;
    } 
    ~auto_ptr()
    {
        if (_ptr)
        {
            cout << "delete:" << _ptr << endl;
            delete _ptr;
        }
    } // 像指针⼀样使⽤
    T & operator*()
    {
        return *_ptr;
    } 
    T* operator->()
    {
        return _ptr;
    }
private:
    T* _ptr;
};
template<class T>
class unique_ptr
{
    
public :
    explicit unique_ptr(T* ptr)
        :_ptr(ptr)
    {}
    ~unique_ptr()
    {
        if (_ptr)
        {
        cout << "delete:" << _ptr << endl;
        delete _ptr;
        }
    } 
    // 像指针⼀样使⽤
    T & operator*()
    {
        return *_ptr;
    } 
    T* operator->()
    {
        return _ptr;
    } 
    unique_ptr(const unique_ptr<T>& sp) = delete;
    unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;
    unique_ptr(unique_ptr<T>&& sp)
        :_ptr(sp._ptr)
    {
        sp._ptr = nullptr;
    } 
    unique_ptr<T>& operator=(unique_ptr<T>&& sp)
    {
        delete _ptr;
        _ptr = sp._ptr;
        sp._ptr = nullptr;
    }
private:
    T* _ptr;
}

2.shared_ptr的原理

上面提到的引用计数是我们这里重点探讨的问题。引用计数这个概念在初识类与对象时就提到过(深浅拷贝的问题)，那么这里的引用计数如何设计？以下有几个设想：

1.将used_count设为static静态变量

我们看到“共享”，首先很容易想到将引用计数设为一个static变量。但这有个致命问题：对于同类型的所有对象，他们都使用同一个引用计数。就比如：

对于同一个对象的引用还好，但一旦对另一个资源引用，如这里的sp3，它使用的仍然为那个static的引用计数，这跟它实际只指向一个资源并不相符。

2.将used_count设置为new出的资源

多个shared_ptr指向资源时就++引⽤计数，shared_ptr对象析构时就--引⽤计数，引⽤计数减到0时代表当前析构的shared_ptr是最后⼀个管理资源的对象，则析构资源。这样的设计是最合理的。

template<class T>
class shared_ptr
{
public:
    shared_ptr(T* ptr)
        : _ptr(ptr)
        , _pcount(new atomic<int>(1))
    {}

    template<class D>
    shared_ptr(T* ptr, D del)
        : _ptr(ptr)
        , _pcount(new atomic<int>(1))
        , _del(del)
    {}

    ~shared_ptr()
    {
        if (--(*_pcount) == 0)
        {
            //delete _ptr;
            _del(_ptr);
            delete _pcount;
        }
    }

    shared_ptr(const shared_ptr<T>& sp)
        : _ptr(sp._ptr)
        , _pcount(sp._pcount)
    {
        (*_pcount)++;
    }

    // sp1 = sp4;
    // sp4 = sp4;
    // sp1 = sp2;
    shared_ptr<T>& operator=(const shared_ptr<T>& sp)
    {
        //if (this != &sp)
        if (_ptr != sp._ptr)
        {
            if (--(*_pcount) == 0)
            {
                delete _ptr;
                delete _pcount;
            }

            _pcount = sp._pcount;
            _ptr = sp._ptr;
            ++(*_pcount);
        }

        return *this;
    }

    T& operator*()
    {
        return *_ptr;
    }

    T* operator->()
    {
        return _ptr;
    }

    int use_count()
    {
        return *_pcount;
    }
private:
    T* _ptr;
    //int* _pcount;
    atomic<int>* _pcount;  // 原子操作

    function<void(T*)> _del = [](T* ptr) {delete ptr; };
};

3.shared_ptr与weak_ptr

• shared_ptr⼤多数情况下管理资源⾮常合适，⽀持RAII，也⽀持拷⻉。但是在循环引⽤的场景下会导致资源没得到释放内存泄漏，所以我们要认识循环引⽤的场景和资源没释放的原因，并且学会使⽤weak_ptr解决这种问题。

• 如下图所述场景，n1和n2析构后，管理两个节点的引⽤计数减到1

1. 右边的节点什么时候释放呢，左边节点中的_next管着呢，_next析构后，右边的节点就释放了。

2. _next什么时候析构呢，_next是左边节点的的成员，左边节点释放，_next就析构了。

3. 左边节点什么时候释放呢，左边节点由右边节点中的_prev管着呢，_prev析构后，左边的节点就释放了。

4. _prev什么时候析构呢，_prev是右边节点的成员，右边节点释放，_prev就析构了。

• ⾄此逻辑上成功形成回旋镖似的循环引⽤，谁都不会释放就形成了循环引⽤，导致内存泄漏

• 把ListNode结构体中的_next和_prev改成weak_ptr，weak_ptr绑定到shared_ptr时不会增加它的引⽤计数，_next和_prev不参与资源释放管理逻辑，就成功打破了循环引⽤，解决了这⾥的问题

struct ListNode
{
    int _data;

    /*ListNode* _next;
    ListNode* _prev;*/
    /*std::shared_ptr<ListNode> _next;
    std::shared_ptr<ListNode> _prev;*/

    // 这里改成weak_ptr，当n1->_next = n2;绑定shared_ptr时
    // 不增加n2的引用计数，不参与资源释放的管理，就不会形成循环引用了
     std::weak_ptr<ListNode> _next;
     std::weak_ptr<ListNode> _prev;

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

int main()
{
    // 循环引用 -- 内存泄露
    std::shared_ptr<ListNode> n1(new ListNode);
    std::shared_ptr<ListNode> n2(new ListNode);

    cout << n1.use_count() << endl;
    cout << n2.use_count() << endl;

    n1->_next = n2;
    n2->_prev = n1;

    cout << n1.use_count() << endl;
    cout << n2.use_count() << endl;

    return 0;
}

4.weak_ptr

• weak_ptr不⽀持RAII，也不⽀持访问资源，所以我们看⽂档发现weak_ptr构造时不⽀持绑定到资源，只⽀持绑定到shared_ptr，绑定到shared_ptr时，不增加shared_ptr的引⽤计数，那么就可以解决上述的循环引⽤问题。

• weak_ptr也没有重载operator*和operator->等，因为他不参与资源管理，那么如果他绑定的shared_ptr已经释放了资源，那么他去访问资源就是很危险的。weak_ptr⽀持expired检查指向的资源是否过期，use_count也可获取shared_ptr的引⽤计数，weak_ptr想访问资源时，可以调⽤lock返回⼀个管理资源的shared_ptr，如果资源已经被释放，返回的shared_ptr是⼀个空对象，如果资源没有释放，则通过返回的shared_ptr访问资源是安全的.

int main()
{
    std::shared_ptr<string> sp1(new string("111111"));
    std::shared_ptr<string> sp2(sp1);

    std::weak_ptr<string> wp = sp1;
    cout << wp.expired() << endl;
    cout << wp.use_count() << endl;

    // sp1和sp2都指向了其他资源，则weak_ptr就过期了
    sp1 = make_shared<string>("222222");
    cout << wp.expired() << endl;
    cout << wp.use_count() << endl;

    sp2 = make_shared<string>("333333");
    cout << wp.expired() << endl;
    cout << wp.use_count() << endl;

    wp = sp1;
    //std::shared_ptr<string> sp3 = wp.lock();
    auto sp3 = wp.lock();
    cout << wp.expired() << endl;
    cout << wp.use_count() << endl;
    sp1 = make_shared<string>("4444444");

    cout << wp.expired() << endl;
    cout << wp.use_count() << endl;

    return 0;
}

5.weak_ptr的工作原理

1. 构造与赋值

一个 weak_ptr 必须从一个已有的 shared_ptr 或另一个 weak_ptr 构造或赋值。

auto sharedPtr = std::make_shared<MyObject>(); // 强引用计数=1, 弱引用计数=0
std::weak_ptr<MyObject> weakPtr(sharedPtr);    // 强引用计数仍=1, 弱引用计数=1

这个过程发生了什么？

• weakPtr 获取了 sharedPtr 所指向的对象指针。

• 更重要的是，weakPtr 也指向了同一个控制块。

• 控制块中的弱引用计数（Weak Count）加 1。强引用计数（Use Count）保持不变。

2. 检查对象是否存活：expired()

weak_ptr 最常用的操作是检查它所观察的对象是否已经被销毁。

if (weakPtr.expired()) {
    std::cout << "Object no longer exists.\n";
}

原理：expired() 内部简单地检查控制块中的强引用计数（Use Count）是否为 0。如果为 0，说明所有拥有该对象的 shared_ptr 都已消亡，对象已被销毁。

3. 安全访问对象：lock()

这是使用 weak_ptr 最主要的方式。你不能直接解引用 weak_ptr。

// 错误！不能直接解引用 weak_ptr
// MyObject& obj = *weakPtr;

// 正确方式
std::shared_ptr<MyObject> sharedPtrFromWeak = weakPtr.lock();
if (sharedPtrFromWeak) { // 检查 lock() 是否成功
    sharedPtrFromWeak->doSomething(); // 安全地使用对象
}

lock() 的原理：我们可以看做，原本的shared_ptr是老大，把循环引用的活交给weak_ptr去管理。但是weak其实找了另一个代理人当老大：实际上又创建了一个shared_ptr。

1. 函数内部检查控制块中的强引用计数（Use Count）。

2. 如果 Use Count > 0（对象还存在）：

   • 它会创建一个新的 shared_ptr。

   • 这个新 shared_ptr 也指向同一个对象和同一个控制块。

   • 强引用计数（Use Count）加 1。

   • 返回这个新创建的 shared_ptr。

3. 如果 Use Count == 0（对象已被销毁）：

   • 返回一个空的 shared_ptr。

4. 析构

当 weak_ptr 本身被销毁（离开作用域时），它会：

• 减少控制块中的弱引用计数（Weak Count）。

• 如果强引用计数和弱引用计数都变为 0（即 use_count == 0 && weak_count == 0），则说明没有任何 shared_ptr 或 weak_ptr 需要这个控制块了，此时控制块的内存也会被释放。

6.shared_ptr的线程安全问题

• shared_ptr的引⽤计数对象在堆上，如果多个shared_ptr对象在多个线程中，进⾏shared_ptr的拷

⻉析构时会访问修改引⽤计数，就会存在线程安全问题，所以shared_ptr引⽤计数是需要加锁或者原⼦操作保证线程安全的。

• shared_ptr指向的对象也是有线程安全的问题的，但是这个对象的线程安全问题不归shared_ptr管，它也管不了，应该有外层使⽤shared_ptr的⼈进⾏线程安全的控制。

• 下⾯的程序会崩溃或者A资源没释放，wjh::shared_ptr引⽤计数从int*改成atomic<int>*就可以保证引⽤计数的线程安全问题，或者使⽤互斥锁加锁也可以。

#include<thread>
#include<mutex>

struct AA
{
    int _a1 = 0;
    int _a2 = 0;

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

int main()
{
    wjh::shared_ptr<AA> p(new AA);
    const size_t n = 100000;

    mutex mtx;
    auto func = [&]()
    {
        for (size_t i = 0; i < n; ++i)
        {
            // 这里智能指针拷贝会++计数
            bit::shared_ptr<AA> copy(p);
            {
                unique_lock<mutex> lk(mtx);
                copy->_a1++;
                copy->_a2++;
            }
        }
    };

    thread t1(func);
    thread t2(func);

    t1.join();
    t2.join();

    cout << p->_a1 << endl;
    cout << p->_a2 << endl;

    cout << p.use_count() << endl;

    return 0;
}

5.内存泄漏

内存泄漏是指程序在动态分配内存后，无法释放已不再使用的内存的情况。随着时间的推移，泄漏的内存会不断累积，导致程序消耗的内存越来越多，最终可能耗尽系统资源。

void memory_leak_example() {
    int* ptr = new int(10);  // 分配内存
    // 使用 ptr...
    // 忘记 delete ptr;  // 内存泄漏！
}

如何监测内存泄漏

linux下内存泄漏检测：linux下⼏款内存泄漏检测⼯具
• windows下使⽤第三⽅⼯具：windows下的内存泄露检测⼯具VLD使⽤_windows内存泄漏检测⼯具-CSDN博客

预防内存泄漏的最佳实践

1. 使用智能指针（RAII）

#include <memory>

void no_leak() {
    // 使用 unique_ptr，内存自动管理
    std::unique_ptr<int> ptr = std::make_unique<int>(10);
    
    // 使用 shared_ptr 和 weak_ptr 避免循环引用
    struct Node {
        std::shared_ptr<Node> next;
        std::weak_ptr<Node> prev; // 使用 weak_ptr 打破循环引用
    };
}

2. 遵循 RAII 原则

class FileHandler {
private:
    FILE* file;
public:
    explicit FileHandler(const char* filename) : file(fopen(filename, "r")) {}
    ~FileHandler() { if(file) fclose(file); }
    
    // 防止拷贝
    FileHandler(const FileHandler&) = delete;
    FileHandler& operator=(const FileHandler&) = delete;
};

3. 使用容器而非手动数组

// 不好
int* create_array(size_t size) {
    return new int[size]; // 需要调用者记得释放
}

// 好
std::vector<int> create_vector(size_t size) {
    return std::vector<int>(size); // 自动管理内存
}

4. 异常安全的代码

void exception_safe() {
    std::unique_ptr<Resource> res1 = std::make_unique<Resource>();
    std::unique_ptr<Resource> res2 = std::make_unique<Resource>();
    
    // 即使这里抛出异常，res1 和 res2 也会自动释放
    risky_operation();
}

C++ 现代编程中的内存管理

在现代 C++ 中，应该尽量避免手动内存管理：

1. 优先使用栈分配：对于生命周期与作用域一致的对象。

2. 使用标准库容器：std::vector, std::string, std::map 等。

3. 使用智能指针：

   • std::unique_ptr：独占所有权

   • std::shared_ptr：共享所有权

   • std::weak_ptr：打破循环引用

4. 避免裸指针：除非与需要裸指针的 API 交互