当前位置：首页 > news >正文

C++_智能指针

news 来源：原创 2025/9/17 22:41:44

一、智能指针的使用场景、基本概念

（1）因为抛异常而出现的资源泄漏的情况

二、RAII和智能指针的设计思路

三、c++标准库智能指针以及使用

（1）几种智能指针的概念

auto_ptr

unique_ptr

shared_ptr

weak_ptr

不是new出来的资源要怎么释放

其他要点

(2)智能指针的原理

四、shared_ptr和weak_ptr

（1）shared_ptr循环引用

五、shared_ptr的线程安全

六、内存泄漏

什么是内存泄漏，内存泄漏的危害

如何避免内存泄漏

一、智能指针的使用场景、基本概念

（1）因为抛异常而出现的资源泄漏的情况

看到这一段代码

double Divide(int a, int b)
{if (b == 0){throw string("Divide by zero condition!");}else{return double(a) / b;}
}
void Func()
{//申请了资源//此时Divide里面抛异常了就走不到后面的delete[]，而是直接回到main中进行异常的捕获//那么就出现了内存泄漏int* arr1 = new int[10];int* arr2 = new int[10];int len = 0, time = 0;cin >> len >> time;Divide(len, time);cout << "delete[] arr1" << endl;cout << "delete[] arr2" << endl;delete[] arr1;delete[] arr2;
}
int main()
{try{Func();}catch (const char* errmsg){cout << errmsg << endl;}catch (const string errmsg){cout << errmsg << endl;}catch (...){cout << "Unkown errmsg" << endl;}return 0;
}

在没有除0情况出现时，程序在调用了Divide后会继续在Func里面执行；已知Divide之前是申请了资源的此时就可以正常走到delete[]；

但是若是出现了除零情况，那么在Divide里面抛异常了就会直接返回到最近且匹配的catch也就是main里面的catch那么在Func函数里面调用Divide这行后面的代码就会因为抛异常而不会执行，那么就会出现资源没有被释放也就是内存泄漏的情况；

###解决方法：

在Func里面也设置异常捕捉的代码，捕捉之后先进行资源释放，之后再重新抛出异常给外层main处理，此时也可以解决：

改进代码：

double Divide(int a, int b)
{if (b == 0){throw string("Divide by zero condition!");}else{return double(a) / b;}
}
void Func()
{int* arr1 = new int[10];int* arr2 = new int[10];try{int len = 0, time = 0;cin >> len >> time;Divide(len, time);}catch(...)//中途捕捉异常进行资源释放{cout << "delete[] arr1" << endl;cout << "delete[] arr2" << endl;delete[] arr1;delete[] arr2;//重新抛出异常给原本应该处理异常的main处理throw;}cout << "delete[] arr1" << endl;cout << "delete[] arr2" << endl;delete[] arr1;delete[] arr2;
}
int main()
{try{Func();}catch (const char* errmsg){cout << errmsg << endl;}catch (const string errmsg){cout << errmsg << endl;}catch (...){cout << "Unkown errmsg" << endl;}return 0;
}

这样只能治标不治本，因为当上面的new也出现抛异常要怎么办？若是arr1抛异常那么情况正常，不会申请任何资源直接被main里面的catch捕捉；但是若是arr2new抛异常了，arr1需要被释放资源那么还要单独写一个释放arr1资源的try catch ；那么当有很多这样的资源申请时，为了避免内存泄漏那就要写很多针对于某种情况的try catch；这会十分复杂，为了解决这种问题，C++引入了智能指针。

二、RAII和智能指针的设计思路

RAII是resource requisition is initialization的缩写；这是一种管理资源类的设计思想，本质是一种利用对象的生命周期来管理获取到的动态资源，避免资源泄漏；这里的资源可以是内存、文件指针、网络连接、互斥锁等；

RAII在获取到资源时将资源委托一个对象，并且可以控制对资源的访问，资源在对象生命周期未结束时始终有效，最后在对象进行析构时释放资源，这样保证了资源的正常释放。

智能指针类除了满⾜RAII的设计思路，还要⽅便资源的访问，所以智能指针类还会想迭代器类⼀

样，重载 operator*/operator->/operator[] 等运算符，⽅便访问资源。

###针对于上面代码的智能指针的使用：

template<class T>
class Smart_Ptr
{
public:Smart_Ptr(T* ptr):_ptr(ptr)//浅拷贝{}~Smart_Ptr(){cout << "delete[]" << endl;delete _ptr;}T& operator *(){return *_ptr;}T* operator ->(){return _ptr;}T& operator [](const int i){return _ptr[i];}
private:T* _ptr;
};
double Divide(int a, int b)
{if (b == 0){throw string("Divide by zero condition!");}else{return double(a) / b;}
}
void Func()
{Smart_Ptr<int> ptr1 = new int[10];Smart_Ptr<int> ptr2 = new int[10];int len = 0, time = 0;cin >> len >> time;Divide(len, time);
}
int main()
{try{Func();}catch (const char* errmsg){cout << errmsg << endl;}catch (const string errmsg){cout << errmsg << endl;}catch (...){cout << "Unkown errmsg" << endl;}return 0;
}

这样即使出现除零情况抛异常了，直接回到main，也不会有资源泄漏；因为当抛异常回到一个函数时，这个链中间的函数会进行栈展开，这些栈展开函数内部的对象生命周期结束了会进行析构；那么在这里就是ptr1和ptr2会自动析构，那么申请的资源就不会泄漏了。

三、c++标准库智能指针以及使用

说明：智能指针确实可以解决上面的问题；不过智能指针最重要的部分就是它的拷贝；我们知道智能指针是管理申请的资源之后能方便资源释放的，若是出现了拷贝，我们希望的拷贝出来的智能指针也管理的是同一份资源；因为被拷贝出来的智能指针不可能凭空去管理另一份资源，也没有新的资源去被它管理，所以此时的拷贝是为了多个智能指针对象共同管理一份资源；那么必然是浅拷贝；但是浅拷贝在析构时就会出现同一份资源释放多次的问题，重要的就是如何解决这个问题

C++标准库中的智能指针都在<memory>这个头文件下面，我们包含<memory>就可以是使⽤了，

智能指针有好几种，除了weak_ptr他们都符合RAII和像指针⼀样访问的行为，原理上而言主要是解 决智能指针拷贝时的思路不同。

（1）几种智能指针的概念

auto_ptr

auto_ptr是C++98时设计出来的智能指针，他的特点是拷⻉时把被拷⻉对象的资源的管理权转移给拷⻉对象，这是⼀个⾮常糟糕的设计，因为它会到被拷贝对象悬空，访问报错的问题，C++11设计出新的智能指针后，强烈建议不要使⽤auto_ptr。其他C++11出来之前很多公司也是明令禁⽌使⽤这个智能指针的。

unique_ptr

unique_ptr 是C++11设计出来的智能指针，它的名字翻译出来是唯⼀指针，它的特点是不⽀持拷

⻉，只⽀持移动。如果不需要拷⻉的场景就⾮常建议使⽤它。

shared_ptr

shared_ptr 是C++11设计出来的智能指针，他的名字翻译出来是共享指针，他的特点是⽀持拷⻉，

也⽀持移动。如果需要拷⻉的场景就需要使⽤他了。底层是⽤引⽤计数的⽅式实现的。

weak_ptr

weak_ptr 是C++11设计出来的智能指针，他的名字翻译出来是弱指针，他完全不同于上⾯的智能指

针，他不⽀持RAII，也就意味着不能⽤它直接管理资源，weak_ptr的产⽣本质是要解决shared_ptr

的⼀个循环引⽤导致内存泄漏的问题。

weak_ptr起到的是一个辅助功能，帮助shared_ptr解决特出场景的错误的。

//简化版实现	
template<class T>class weak_ptr{public://支持空的构造函数weak_ptr(){}weak_ptr(const shared_ptr<T>& sp):_ptr(sp.get()){}weak_ptr<T>& operator=(const shared_ptr<T>& sp){_ptr = sp.get();}private:T* _ptr = nullptr;};

不是new出来的资源要怎么释放

智能指针析构时默认是进⾏delete释放资源，这也就意味着如果不是new出来的资源，交给智能指

针管理，析构时就会崩溃。智能指针⽀持在构造时给⼀个删除器，所谓删除器本质就是⼀个可调⽤

对象，这个可调⽤对象中实现你想要的释放资源的⽅式，当构造智能指针时，给了定制的删除器，

在智能指针析构时就会调⽤删除器去释放资源。因为new[]经常使⽤，所以为了简洁⼀点，

unique_ptr和shared_ptr都特化了⼀份[]的版本，使⽤时 unique_ptr<Date[]> up1(new

Date[5]);shared_ptr<Date[]> sp1(new Date[5]); 就可以管理new []的资源。

自己使用智能指针时若不是new出来的对象就需要自己写仿函数或者函数指针或者lambda表达式传给删除器；

template<class T>
void DeleteArrayFunc(T* ptr)
{delete[] ptr;
}
template<class T>
class DeleteArray
{
public:void operator()(T* ptr){delete[] ptr;}
};class Fclose
{
public:void operator()(FILE* ptr){std::cout << "fclose:" << ptr << std::endl;fclose(ptr);}
};
int main()
{// 这样实现程序会崩溃// unique_ptr<Date> up1(new Date[10]);// shared_ptr<Date> sp1(new Date[10]);// 解决⽅案1// 因为new[]经常使⽤，所以unique_ptr和shared_ptr// 实现了⼀个特化版本，这个特化版本析构时⽤的delete[]std::unique_ptr<Date[]> up1(new Date[5]);std::shared_ptr<Date[]> sp1(new Date[5]);// 解决⽅案2// 仿函数对象做删除器//unique_ptr<Date, DeleteArray<Date>> up2(new Date[5], DeleteArray<Date>());// unique_ptr和shared_ptr⽀持删除器的⽅式有所不同// unique_ptr是在类模板参数⽀持的，shared_ptr是构造函数参数⽀持的// 使⽤仿函数unique_ptr可以不在构造函数传递，因为仿函数类型构造的对象直接就可以调⽤// 但是下⾯的函数指针和lambda的类型不可以//仿函数std::unique_ptr<Date,DeleteArray<Date>> up2(new Date[5]);std::shared_ptr<Date> sp2(new Date[5],DeleteArray<Date>());//函数指针std::unique_ptr<Date, void(*)(Date*)> up3(new Date[5],DeleteArrayFunc<Date>);std::shared_ptr<Date> sp3(new Date[5], DeleteArrayFunc<Date>);//lambda表达式auto delArrOBJ = [](Date* ptr) {delete ptr; };std::unique_ptr<Date, decltype(delArrOBJ)> up4(new Date[5], delArrOBJ);std::shared_ptr<Date> sp4(new Date[5], delArrOBJ);//其他资源类型std::unique_ptr<FILE, Fclose> up5(fopen("Test.cpp","r"), Fclose());std::shared_ptr<FILE> sp5(fopen("Test1.cpp", "r"),Fclose());std::shared_ptr<FILE> sp6(fopen("Test2.cpp", "r"), [](FILE* ptr){std::cout << "fclose:" << ptr << std::endl;fclose(ptr);});return 0;
}

其他要点

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 修饰，防⽌普通指针隐式类型转换

成智能指针对象。

int main()
{//make_sharedstd::shared_ptr<Date> sp1 = std::make_shared<Date>(100, 100, 100);auto sp2 = std::make_shared<Date>(100, 100, 100);//向operator bool 的类型转换std::shared_ptr<Date> sp3 = std::make_shared<Date>(100, 100, 100);std::shared_ptr<Date> sp4 = std::make_shared<Date>(100, 100, 100);if (sp3)std::cout << "sp3 is not nullptr" << std::endl;elsestd::cout << "sp3 is nullptr" << std::endl;if (sp4)std::cout << "sp4 is not nullptr" << std::endl;elsestd::cout << "sp4 is nullptr" << std::endl;//explicit构造时不支持隐式类型转换//std::shared_ptr<Date> sp5 = new Date(100,100,100);std::shared_ptr<Date> sp5 (new Date(100, 100, 100));return 0;
}

(2)智能指针的原理

也就是这样的：auto_ptr拷贝时先把作为拷贝模板的智能指针管理的资源交给被拷贝对象，之后再把作为拷贝模板的对象的管理资源成员变量的那个指针悬空，那么就进行了管理资源权的转移；此时之前的那个智能智能就再无法使用了

auto_ptr的实现：

template<class T>class auto_ptr{public:auto_ptr(T* ptr):_ptr(ptr){}//拷贝构造auto_ptr(auto_ptr<T>& ap):_ptr(ap._ptr){ap._ptr = nullptr;}//赋值重载auto_ptr<T>& operator=(auto_ptr<T>& ap){if (_ptr != ap._ptr)//防止自我赋值{if (_ptr)//先释放原来的资源，因为被赋值之后也没有管理它的了delete _ptr;_ptr = ap._ptr;ap._ptr = nullptr;}return *this;}~auto_ptr(){if (_ptr)delete _ptr;}T& operator * (){return *_ptr;}T* operator & (){return _ptr;}private:T* _ptr;};

unique_ptr

template<class T>
class unique_ptr
{
public:explicit unique_ptr(T* ptr):_ptr(ptr){}//不持支拷贝构造和赋值重载unique_ptr(unique_ptr<T>& up) = delete;unique_ptr<T>& operator = (unique_ptr<T>& up) = delete;//支持移动语义unique_ptr(unique_ptr<T>&& up) :_ptr(up._ptr){up._ptr = nullptr;}unique_ptr<T>& operator = (unique_ptr<T>&& up) {if (_ptr != up._ptr){if (_ptr)delete _ptr;_ptr = up._ptr;up._ptr = nullptr;}return *this;}T* operator & (){return _ptr;}T& operator * (){return *_ptr;}
private:T* _ptr;
};

shared_ptr

引用计数增加的计数器不能是静态成员变量，否则一个不是管理资源A的shared_ptr出现了，管理资源A的计数器也会++，因为静态成员变量为同一类模板实例化出来的对象所共有；

这里要使用动态开辟，也就是说，当一个shared_ptr被创建时，要为这个智能指针申请一份资源给计数器，那么拷贝构造，这个计数器就++，析构时计数器--，若是计数器减到0，那么就需要是释放管理的这份资源；

赋值重载时若是没有判断自我赋值的情况，当计数器为1时，--计数器，此时会释放资源，后面又用到*_cnt，那么就出现了空指针的解引用，（智能指针的地址和其成员变量_ptr地址一样）

	template<class T>class shared_ptr{public:explicit shared_ptr(T* ptr):_ptr(ptr),_cnt(new int(1))//构造计数器就是1，代表此时新建了一个shared指针，并且这份资源开始被管理{}shared_ptr(shared_ptr<T>& sp):_ptr(sp._ptr),_cnt(sp._cnt){//拷贝构造意味着多了一个管理这份资源的shared_ptr//所以就让计数器++++(*_cnt);}shared_ptr<T>& operator=(shared_ptr<T>& sp){//赋值重载//首先让_ptr的计数器--，并且若是--之后计数器为0，则释放资源//接着让_ptr指向的资源为sp管理的资源，并且让对应的计数器++//注意：可能出现自我赋值的情况，此时判断一下就行if (_ptr != sp._ptr){if (--(*_cnt) == 0){//释放资源delete[] _ptr;delete _cnt;_ptr = nullptr;_cnt = nullptr;}//赋值_ptr = sp._ptr;_cnt = sp._cnt;++(*_cnt);}return *this;}~shared_ptr(){--(*_cnt);if (*_cnt == 0){delete[] _ptr;delete _cnt;_ptr = nullptr;_cnt = nullptr;}}T* get() const{return _ptr;}int count_use()const{return *_cnt;}private:T* _ptr;int* _cnt;};

基本的实现之后，还得处理不是new出来的资源的情况；

首先shared_ptr处理这种情况是将针对特定释放资源的仿函数、lambda表达式一类的方法传递给构造函数的第二个参数，之后这个对象在析构时就调用这个方法；

那么因为不是类型，而是具体的参数，所以shared_ptr类模板还是只有一个模板参数，但是在这个类中，要实现一份构造函数的函数模板用来接收构造时传的方法类型，从而后序能够使用；

但是这个参数在拷贝或者赋值时也要传给其他shared_ptr对象，所以应该把这个删除器类型置为成员变量，这样就能拷贝和赋值了；

这个成员变量要给缺省，因为一般情况下都是处理new出来的资源，所以不会传删除器，默认的删除器用delete；缺省值给的是方法也就是仿函数、lambda表达式，但是些方法没有固定类型，所以可以用包装器function接收。

具体代码：

	template<class T>class shared_ptr{public:explicit shared_ptr(T* ptr):_ptr(ptr), _cnt(new int(1)){}//支持有删除器的构造函数template<class D>shared_ptr(T* ptr, D del): _ptr(ptr), _cnt(new int(1)), _del(del){}shared_ptr(shared_ptr<T>& sp):_ptr(sp._ptr), _cnt(sp._cnt), _del(sp._del){++(*_cnt);}shared_ptr<T>& operator=(shared_ptr<T>& sp){//赋值重载//首先让_ptr的计数器--，并且若是--之后计数器为0，则释放资源//接着让_ptr指向的资源为sp管理的资源，并且让对应的计数器++//注意：可能出现自我赋值的情况，此时判断一下就行if (_ptr != sp._ptr){if (--(*_cnt) == 0){//释放资源if (_ptr)_del(_ptr);if (_cnt)delete _cnt;_ptr = nullptr;_cnt = nullptr;}//赋值_ptr = sp._ptr;_cnt = sp._cnt;_del = sp._del;++(*_cnt);}return *this;}~shared_ptr(){--(*_cnt);if (*_cnt == 0){if(_ptr)_del(_ptr);if(_cnt)delete _cnt;_ptr = nullptr;_cnt = nullptr;}}T* get() const{return _ptr;}int use_count()const{return *_cnt;}private:T* _ptr;int* _cnt;std::function<void(T*)> _del = [](T* ptr) { delete ptr; };};

测试：

	Test::shared_ptr<Date> sp1(new Date);//拷贝构造Test::shared_ptr<Date> sp2(sp1);std::cout << "sp1: " << sp1.use_count() << std::endl;//赋值重载Test::shared_ptr<Date> sp3(new Date);sp2 = sp3;std::cout <<"sp1: " << sp1.use_count() << std::endl;std::cout <<"sp3: " << sp3.use_count() << std::endl;return 0;

delete的时候会去调用析构函数，释放动态开辟的资源

	其他资源的释放Test::shared_ptr<FILE> sp4(fopen("Test.cpp", "r"), Fclose());Test::shared_ptr<FILE> sp5(fopen("Test.cpp", "r"), [](FILE* ptr) { std::cout << "fclose" << std::endl; delete ptr; });Test::shared_ptr<Date> sp6(new Date[3], [](Date* ptr) {delete[] ptr; });

四、shared_ptr和weak_ptr

shared_ptr⼤多数情况下管理资源⾮常合适，⽀持RAII，也⽀持拷⻉。但是在循环引⽤的场景下会

导致资源没得到释放内存泄漏，所以我们要认识循环引⽤的场景和资源没释放的原因，并且学会使

⽤weak_ptr解决这种问题。

（1）shared_ptr循环引用

循环引用例子：

两个节点指针，用两个不同的shared管理，前面节点指针的next指向后一个，后面的prev指针指向前一个，又因为next和prev也是shared的类型，当它们指向一个节点是也就是相当于赋值重载，那么count_use也会增加；所以指向完毕之后，这两个节点的count_use就是2，在程序结束之后，进行析构，析构的是这两个节点，计数器只会-1，但是需要到0才会释放资源，那么此时资源就不会释放，内存泄漏了。

也就是原本只用一个shared管理节点，但是用shared类型的next或者prev指针再指向这个节点后，next或者prev也会管理这个节点，最后析构时会因为计数器没有减到0二不会释放资源

具体代码：

struct ListNode
{int _data;std::shared_ptr<ListNode> _next;std::shared_ptr<ListNode> _prev;//std::weak_ptr<ListNode> _next;//std::weak_ptr<ListNode> _prev;ListNode(int data = 0):_data(data){}~ListNode(){std::cout << "~ListNode()" << std::endl;}
};
int main()
{std::shared_ptr<ListNode> n1(new ListNode(1));std::shared_ptr<ListNode> n2(new ListNode(2));std::cout << n1.use_count() << std::endl;std::cout << n2.use_count() << std::endl;n1->_next = n2;n2->_prev = n1;std::cout << n1.use_count() << std::endl;std::cout << n2.use_count() << std::endl;return 0;
}

结果没有析构

将_next _prev的类型改为weak_ptr：

引用计数数字不变，智能指针析构时delete调用listNode的析构函数：

五、shared_ptr的线程安全

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

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

原⼦操作保证线程安全的。

shared_ptr指向的对象也是有线程安全的问题的，但是这个对象的线程安全问题不归shared_ptr

管，它也管不了，应该有外层使⽤shared_ptr的⼈进⾏线程安全的控制。

下⾯的程序会崩溃或者A资源没释放，bit::shared_ptr引⽤计数从int*改成atomic<int>*就可以保证

引⽤计数的线程安全问题，或者使⽤互斥锁加锁也可以。

#include<thread>
struct AA
{int _a1 = 0;int _a2 = 0;~AA(){std::cout << "~AA()" << std::endl;}
};
int main()
{Test::shared_ptr<AA> p(new AA);const size_t n = 100000;mutex mtx;auto func = [&](){for (size_t i = 0; i < n; ++i){// 这⾥智能指针拷⻉会++计数Test::shared_ptr<AA> copy(p);{unique_lock<mutex> lk(mtx);copy->_a1++;copy->_a2++;}}};std::thread t1(func);std::thread t2(func);t1.join();t2.join();std::cout << p->_a1 << std::endl;std::cout << p->_a2 << std::endl;std::cout << p.use_count() << std::endl;return 0;
}

shared_ptr本身是线程安全的，但是它管理的资源不是

六、内存泄漏

什么是内存泄漏，内存泄漏的危害

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使⽤的内存，⼀般是忘记释放或者发⽣异常释放程序未能执⾏导致的。内存泄漏并不是指内存在物理上的消失，⽽是应⽤程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因⽽造成了内存的浪费。

内存泄漏的危害：普通程序运⾏⼀会就结束了出现内存泄漏问题也不⼤，进程正常结束，⻚表的映射关系解除，物理内存也可以释放。⻓期运⾏的程序出现内存泄漏，影响很⼤，如操作系统、后台服务、⻓时间运⾏的客⼾端等等，不断出现内存泄漏会导致可⽤内存不断变少，各种功能响应越来越慢，最终卡死。

如何避免内存泄漏

⼯程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理

想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下⼀条智能指针来管理

才有保证。

尽量使⽤智能指针来管理资源，如果⾃⼰场景⽐较特殊，采⽤RAII思想⾃⼰造个轮⼦管理。

定期使⽤内存泄漏⼯具检测，尤其是每次项⽬快上线前，不过有些⼯具不够靠谱，或者是收费。

总结⼀下：内存泄漏⾮常常⻅，解决⽅案分为两种：1、事前预防型。如智能指针等。2、事后查错

型。如泄漏检测⼯具。

一、智能指针的使用场景、基本概念

（1）因为抛异常而出现的资源泄漏的情况

二、RAII和智能指针的设计思路

三、c++标准库智能指针以及使用

（1）几种智能指针的概念

auto_ptr

unique_ptr

shared_ptr

weak_ptr

不是new出来的资源要怎么释放

其他要点

(2)智能指针的原理

四、shared_ptr和weak_ptr

（1）shared_ptr循环引用

五、shared_ptr的线程安全

六、内存泄漏

什么是内存泄漏，内存泄漏的危害

如何避免内存泄漏

相关文章：