目录

前言

内存泄漏

RAII

智能指针原理

智能指针分类

auto_ptr

unique_ptr

shared_ptr

两个问题

线程安全

循环引用

后记

---

前言

        对于智能指针，听起来很高大上，其实本质上就是一个类。为什么叫指针呢？因为可以像指针一样管理一块资源；为什么又加上智能两个字呢？因为比普通指针更特殊一点，特殊在它是一个类。比如说，当我们使用一个指针去new一块空间时，最后要delete去释放资源，在不注意时就会忘记导致内存泄漏，或者因为像上一章节中throw这样会跳跃的语句，当跳过delete又该怎么办呢？这就需要使用到RAII的思想，在下面将会介绍到，在此之前我们先介绍一下内存泄漏的危害，以此来强调一下智能指针的重要性。

内存泄漏

        内存泄漏通常发生在程序中有未释放的内存空间，导致程序的内存占用不断增加。这可能是由于以下原因之一导致的：

1. 程序中使用了动态内存分配函数（如malloc、calloc等）分配的内存，但在使用完后未使用free等函数释放内存；

2. 程序中存在指针错误，导致内存无法访问或释放；

3. 程序中存在死循环或递归，导致一些内存空间无法被释放；

4. 程序中存在逻辑错误，导致内存未能被正确地分配或释放，

        内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费，导致响应越来越慢，最终卡死。

eg：

void MemoryLeak()
{//内存申请了最后忘记释放int* p1 = (int*)malloc(sizeof(int));int* p2 = new int;//异常安全问题int* p3 = new int[10];Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.delete[] p3;
}

 如何避免内存泄漏：

        ①养成好的编程习惯，对容易造成内存泄漏的语句产生敏感，比如new出来的空间紧接着释放，然后在在中间写使用此空间的逻辑，若涉及异常安全问题，应注意在new的空间所在的栈帧捕获拦截一下，将相应资源释放再处理异常；

        ②使用提前实现的私有内存管理库，自带内存泄漏检测的功能，比如内存池；

        ③使用内存泄漏检测工具，但这类工具不靠谱且收费；

        ④采用智能指针或其思想——RAII来管理资源，下面介绍。

RAII

        RAII 是 Resource Acquisition Is Initialization 的缩写，即资源获取即初始化。用于管理资源（如内存、文件句柄、网络连接等）的生命周期。RAII 基本思想是将资源的创建和释放绑定在一个对象的构造和析构过程中，通过对象的生命周期来管理资源。

        在使用 RAII 时，需要创建一个对象来管理资源，这个对象在构造函数中获取资源，然后在析构函数中释放资源。这样一来，无论是因为异常还是正常的程序流程终止，都可以确保资源得以释放，不会导致内存泄漏或资源占用问题。

优点：

1. 保证资源分配和释放的可靠性，减少了程序错误的风险；
2. 使代码更加简洁、易于维护和阅读；
3. 避免了程序员必须手动跟踪资源分配和释放，从而减少了程序员的工作量，

        RAII 是面向对象设计和编程的一种实践，在 C++ 中得到了广泛的应用。例如，在 C++ 标准库中就使用了 RAII 的技术实现了自动内存管理、文件操作和线程同步等功能。

eg：

template <class T>
class PTR
{
public:PTR(T* ptr = nullptr):_ptr(ptr){}~PTR(){if (_ptr)delete _ptr;}
private:T* _ptr = nullptr;
};int main()
{PTR<int> p1(new int);PTR<int> p2(new int[10]);return 0;
}

智能指针原理

        前面说过，智能指针本质就是一个类，虽应用了RAII思想还不够，还需要具备普通指针的功能，也就是解引用和->访问空间中的内容，重载操作符即可。

eg：

template <class T>
class Smartptr
{
public:Smartptr(T* ptr = nullptr):_ptr(ptr){}~Smartptr(){if (_ptr)delete _ptr;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}
private:T* _ptr = nullptr;
};

智能指针分类

• auto_ptr

        在c++98，stl就提供了一版智能指针——auto_ptr，下面是一份模拟实现，框架与上面的Smartptr一样，在此基础上实现了拷贝构造函数和赋值运算符重载，可以看到，auto_ptr的实现原理在于资源管理权的转移。

        对于拷贝构造函数，将被拷贝对象内部指针指向的资源赋给当前对象的内部指针，且将被拷贝对象内部指针指向空；对于赋值运算符重载，若当前对象内部指针有指向资源，那么直接将此资源释放，然后将被拷贝对象内部指针指向的资源赋给当前对象的内部指针，再将被拷贝对象内部指针指向空。

        可以从模拟实现看出，auto_ptr是一个较为失败的提出，有很多公司明确指出不能使用此智能指针，比如说，当一个智能指针对象赋值给另一个对象时，那么当前智能指针对象在后续就不能用了，因为已经不再管理那一块资源了。可想而知这不是我们想要的功能，我们想要的是在赋值给其他对象之后，自己依旧可以继续管理那块资源，与其他对象一块管理。

 模拟实现：

template <class T>
class Auto_ptr
{
public:Auto_ptr(T* ptr = nullptr):_ptr(ptr){}~Auto_ptr(){if (_ptr)delete _ptr;}Auto_ptr(Auto_ptr<T>& ap):_ptr(ap._ptr){ap._ptr = nullptr;}Auto_ptr<T>& operator=(Auto_ptr<T>& ap){if (this != &ap){if (_ptr){delete _ptr;}_ptr = ap._ptr;ap._ptr = nullptr;}return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}
private:T* _ptr = nullptr;
};

test：

• unique_ptr

        c++11中，stl又提出另一款智能指针——unique_ptr，实现原理也是简单粗暴，因为上面的auto_ptr在赋值以后被赋值指针在后续就不能继续管理那块资源了，所以unique_ptr直接禁止拷贝和赋值，也就是一个智能指针对象在构造时就决定了管理哪块资源，后续就不能变了，有新的资源需要被管理，只能重新构造一个对象，下面是unique_ptr的模拟实现。

模拟实现：

template <class T>
class Unique_ptr
{
public:Unique_ptr(T* ptr = nullptr):_ptr(ptr){}~Unique_ptr(){if (_ptr){delete _ptr;}}Unique_ptr(Unique_ptr<T>& up) = delete;Unique_ptr<T>& operator=(Unique_ptr<T>& up) = delete;T& operator*(){return *_ptr;}T* operator->(){return _ptr;}
private:T* _ptr = nullptr;
};

 test：

• shared_ptr

        与上面两个智能指针不同，c++11中还有一款智能指针——shared_ptr，这款智能指针就如同我们想象的那样了，可以支持赋值拷贝，而且复制拷贝之后，原对象依旧可以管理那一块资源，与赋值对象一块管理。shared_ptr的原理在于通过引用计数的方式来实现多个对象之间共享资源，最后一个析构对象释放资源。具体地，在shared_ptr内部，每个资源都维护了着一份计数，用来记录该份资源被几个对象共享，在对象被销毁时(调用析构函数)，就说明自己不使用该资源了，对象的引用计数减一，如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源，如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源。

        下面是模拟实现，除了Smartptr基本的框架外，成员属性还多个_pCount用来计数，本质是申请一块int大小的空间记录对应资源的被指向个数，两块资源一一对应，比如说，

这里使用一一对应的一块资源去引用计数就很巧妙，想一下为什么不用静态成员变量去计数？这个问题后面会说。

        继续，_pCount在构造函数中初始化为1，在析构函数中如果是最后一个指向资源的对象，则与资源一块被释放，否则将计数减一。最主要的还是拷贝构造函数和赋值运算符重载的实现，对于拷贝构造函数，将指向的资源与计数资源赋值给目标对象之后，将计数加一；对于赋值运算符重载，因为涉及到原对象资源的释放，所以较为复杂一点，首先根据原对象中的引用计数决定是否要释放原对象指向的资源还是计数减一，再指向被赋值对象的资源，将计数加一即可。

模拟实现：

template <class T>
class Shared_ptr
{
public:Shared_ptr(T* ptr = nullptr):_ptr(ptr),_pCount(new int(1)){}~Shared_ptr(){if (--(*_pCount) == 0){delete _ptr;delete _pCount;}}Shared_ptr(Shared_ptr<T>& sp){_ptr = sp._ptr;_pCount = sp._pCount;(*_pCount)++;}Shared_ptr<T>& operator=(Shared_ptr<T>& sp){if (_ptr != sp._ptr)   //这里不建议用(this!=&sp)，因为除了同一个对象不能进行赋值操作，//而且指向同一块资源的两个对象也不进行赋值运算{if (--(*_pCount) == 0){delete _ptr;delete _pCount;}_ptr = sp._ptr;_pCount = sp._pCount;(*_pCount)++;}return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr = nullptr;int* _pCount;
};

 test：

为什么不使用静态成员static int _count去计数呢？

        因为静态成员属于整个类，属于此类实例化出的所有对象，我们需要一个资源配对一个计数，要是使用静态成员计数，则所有资源都只有这一个计数，比如：

        想一下上面实现的shared_ptr还有啥问题不？当我们申请一个数组大小的资源或者使用malloc去申请资源时，类内实现的析构函数还能用吗？我们知道，删除数组资源需要使用delete[]，删除使用malloc申请的资源需要用free释放，所以类内只是用delete释放资源是不全面的。这里我们可以通过在类模板参数中传入删除器的类决定释放资源的方式。在stl库里，shared_ptr的删除器是在构造时传入删除器对象，这种不太好实现，至少以现在的简单架构不好实现，所以采用在模板参数处传入删除器的方法，如下。

带删除器版本的shared_ptr模拟实现：

//默认
template <class T>
struct Delete
{void operator()(T* ptr){//cout << "delete" << endl;delete ptr;}
};
//删除数组申请的资源
template <class T>
struct deleteArray
{void operator()(T* ptr){cout << "delete[]" << endl;delete[] ptr;}
};
//删除malloc申请的资源
template <class T>
struct freeFunc
{void operator()(T* ptr){cout << "free" << endl;free(ptr);}
};template <class T, class D = Delete<T>>
class Shared_ptr
{
public:Shared_ptr(T* ptr = nullptr):_ptr(ptr), _pCount(new int(1)){}~Shared_ptr(){D del;if (--(*_pCount) == 0){del(_ptr);delete _pCount;}}Shared_ptr(Shared_ptr<T>& sp){_ptr = sp._ptr;_pCount = sp._pCount;(*_pCount)++;}Shared_ptr<T>& operator=(Shared_ptr<T>& sp){D del;if (_ptr != sp._ptr)   //这里不建议用(this!=&sp)，因为除了同一个对象不能进行赋值操作，//而且指向同一块资源的两个对象也不进行赋值运算{if (--(*_pCount) == 0){del(_ptr);delete _pCount;}_ptr = sp._ptr;_pCount = sp._pCount;(*_pCount)++;}return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr = nullptr;int* _pCount;
};

test：

两个问题

• 线程安全

        后面写

• 循环引用

        从上面的一系列智能指针可以看出，shared_ptr是当中最符合实际情况使用的一个，但是在后续使用的过程中，有人发现有些场景使用智能指针引发了意料之外的结果，导致这个结果的原因就是循环引用的问题，看下面这个例子（其中use_count函数是返回智能指针的引用计数）：

struct Node
{~Node(){cout << "~node" << endl;  //无别的作用，只是看Node资源有无释放}int _data;shared_ptr<Node> _next;shared_ptr<Node> _prev;
};void testRotateRef()
{shared_ptr<Node> n1(new Node);shared_ptr<Node> n2(new Node);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;
}

         对于链表节点类，我们使用智能指针去管理资源，为什么我们类内的next、prev也使用智能指针定义呢？因为会存在赋值时有类型转换问题，比如n1->_next = n2;，那么问题就来了，我们先编译一下testRotateRef函数：

        先甭管引用计数的变化，我们可以看到n1、n2的Node资源并没有释放（也就是没有打印出~Node），这是怎么回事呢？截图中可以看出，n1、n2定义完以后的引用计数都是1很正常，经过n1->_next = n2;n2->_prev = n1;后，引用计数都变成了2也正常，因为对于n2的资源，多了个n1的next智能指针指向n2资源，对于n1资源也是一样，所以引用计数都是2很正常，但是当这些语句走完时，正常来说两个Node节点资源应该释放了，但是并没有，因为两个资源的引用计数都是2，无法得以释放，图解如下：

        上图可以看出，n1、n2在出作用域即将释放时，由于引用计数不是1，从而无法释放，导致这一现象的正是循环引用的问题，也就是两个资源互相牵制，使彼此无法正常释放。针对这个现象，c++11提出了weak_ptr的智能指针，捆绑shared_ptr以解决循环引用的问题，可看作shared_ptr的小跟班，可相互赋值，本质就是不参与资源的释放管理，因此不增加计数，但是可以访问修改资源。我们将Node类内的智能指针的类型改为weak_ptr再试一次：

        可以看到，指向前后的引用计数并没有变化，而且两个Node节点资源得以释放，这就解决了循环引用的问题。

        下面我们也模拟实现一下weak_ptr，如下代码块（其中get函数是返回智能指针的类内原生指针），除了Smart_ptr的基础框架，也除了基本的构造函数、拷贝构造函数、赋值运算符重载以外，类内多了个用shared_ptr类型构造的拷贝构造函数（也有用shared_ptr类型的赋值运算符重载，这里没写），这保证了weak_ptr和shared_ptr之间可以相互赋值，同时无析构函数，因为weak_ptr不参与资源的释放管理，资源的释放管理应该交给shared_ptr，因此无需析构函数释放资源。

template <class T>
class Weak_ptr
{
public:Weak_ptr():_ptr(nullptr){}Weak_ptr(const Shared_ptr<T>& sp):_ptr(sp.get()){}Weak_ptr(const Weak_ptr<T>& wp):_ptr(wp._ptr){}Weak_ptr<T>& operator=(const Weak_ptr<T>& wp){_ptr = wp._ptr;return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}
private:T* _ptr;
};

后记

        智能指针是c++区别于其他语言独有的一个功能，但是并不是说其他语言没有前言中讲述的问题，只是有别的处理方法，比如java有垃圾处理器，能够将new的资源自动回收。智能指针本身不重要，重要的是RAII的思想，能将资源的管理交给一个类，这个方法就很符合面向类和对象的语言，并且智能指针的知识点在面试中被问到的频率非常高，比如手撕一个智能指针，RAII的思想是什么，针对于本文的最后两个问题中的提问点也有很多，这一章节不是特别难，希望大家可以深入学习一下，可以在面试中从容的面对任何提问。

---