📝个人主页🌹：Eternity._

⏩收录专栏⏪：C++ “ 登神长阶 ”

🤡往期回顾🤡：C++异常处理机制

🌹🌹期待您的关注 🌹🌹

❀C++智能指针

📒1. 智能指针的引入📚2. 智能指针的使用及原理⛰️RAII🌄智能指针的原理🌞std::auto_ptr🌙std::unique_ptr⭐std::shared_ptr与std::weak_ptr

📜3. 内存泄漏🍁内存泄漏的危害🍂内存泄漏的分类与检测 (了解)🌸如何避免内存泄漏

📝4. C++11和boost中智能指针的关系📖5. 总结

---

前言：在C++的浩瀚宇宙中，内存管理一直是程序员们必须面对的重要课题。从早期的手动分配与释放，到现代C++标准库中引入的智能指针，每一次进步都标志着C++在提升开发效率、减少错误风险方面的巨大飞跃。智能指针，作为C++11及后续版本中不可或缺的一部分，不仅极大地简化了资源管理，还通过其独特的机制有效防止了内存泄漏和野指针的出现，成为了现代C++编程中不可或缺的工具

本文旨在带领读者深入探索C++智能指针的奥秘，从std::unique_ptr到std::shared_ptr，再到较为特殊的std::weak_ptr，我们将一一剖析这些智能指针的设计理念、使用方法、以及它们背后的原理。通过实例演示和理论解析相结合的方式，帮助读者不仅学会如何正确使用智能指针，更能理解其背后的RAII（Resource Acquisition Is Initialization）资源管理思想，从而在C++编程中更加游刃有余地管理资源

我们将一起踏上探索C++智能指针的奇妙旅程，共同见证它在提升代码质量、保障程序安全方面的巨大力量，让我们携手前行，在C++的编程世界中，共同书写属于自己的辉煌篇章！

---

📒1. 智能指针的引入

内存方面情景代码示例 (C++)：

<code>int div()

{ -- -->

int a, b;

cin >> a >> b;

if (b == 0)

{

throw invalid_argument("除0错误");

}

return a / b;

}

void Func()

{

int* p1 = new int;

int* p2 = new int;

cout << div() << endl;

delete p1;

cout << "delete p1" << p1 << endl;

delete p2;

cout << "delete p2" << p2 << endl;

}

int main()

{

try

{

Func();

}

catch (exception& e)

{

cout << e.what() << endl;

}

return 0;

}

当我们正常输入时：程序正常

当我们程序异常终止时：申请的空间并不会被释放

这样就会造成<code>内存泄漏，因此为了能够限制内存泄漏，就有了智能指针

---

📚2. 智能指针的使用及原理

智能指针（Smart Pointers）是现代C++编程中非常重要的一种内存管理技术，旨在解决原始指针使用过程中的内存泄漏、野指针等问题。智能指针是模板类，能够像普通指针一样被操作，但它能在适当的时候自动释放所管理的对象，从而保证资源的正确释放

---

⛰️RAII

RAII是一种在C++（以及C++风格的其他编程语言中）常用的资源管理技术。

它的基本思想是：资源的获取在对象的构造时完成，而资源的释放（Release）则在对象的生命周期结束时自动执行，通常是在对象的析构函数中完成。我们实际上把管理一份资源的责任托管给了一个对象，这种方式有助于管理如动态分配的内存、文件句柄、网络连接、互斥锁等需要显式释放的资源

RAII的好处

自动资源管理： RAII通过对象的生命周期来管理资源，一旦对象被销毁，其所管理的资源也会被自动释放，无需手动调用释放函数异常安全： 由于资源的释放是在对象的析构函数中进行的，而析构函数会在对象生命周期结束时自动调用，即使发生异常也是如此，因此可以保证资源的正确释放，避免了资源泄露简化代码： 使用RAII可以使得资源管理相关的代码更加简洁，减少了因忘记释放资源而导致的错误

使用RAII思想设计的SmartPtr类：

template<class T>

class SmartPtr { -- -->

public:

SmartPtr(T* ptr = nullptr)

: _ptr(ptr)

{ }

~SmartPtr()

{

cout << "delete -> " << _ptr << endl;

delete _ptr;

}

private:

T* _ptr;

};

---

🌄智能指针的原理

但是刚刚的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用

template<class T>

class SmartPtr

{

public:

SmartPtr(T* ptr)

:_ptr(ptr)

{ }

~SmartPtr()

{

cout << "delete -> " << _ptr << endl;

delete _ptr;

}

T& operator*()

{

return *_ptr;

}

T* operator->()

{

return _ptr;

}

private:

T* _ptr;

};

int main()

{

SmartPtr<int> sp1(new int);

*sp1 = 10

cout<<*sp1<<endl;

return 0;

}

智能指针的原理：

RAII特性重载operator*和opertaor->，具有像指针一样的行为

---

🌞std::auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针

std::auto_ptr文档

<code>auto_ptr的实现原理：管理权转移的思想，我们来简单模拟实现一下它，来了解它的原理

---

auto_ptr模拟实现 (C++)：

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 = nullptr;

}

return *this;

}

~auto_ptr()

{

if (_ptr)

{

cout << "delete -> " << _ptr << endl;

delete _ptr;

_ptr = nullptr;

}

}

T& operator*()

{

return *_ptr;

}

T* operator->()

{

return _ptr;

}

private:

T* _ptr;

};

但是由于auto_ptr存在较严重的问题，很多公司明确要求不能使用

void Test_auto_ptr()

{

pxt::auto_ptr<int> ap1(new int);

pxt::auto_ptr<int> ap2 = ap1;

// 管理权转移，导致ap1对象悬空

/*(*ap1)++;

(*ap2)++;*/

}

---

🌙std::unique_ptr

C++11中开始提供更靠谱的unique_ptr

std::unique_ptr文档文档

<code>unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份unique_ptr来了解它的原理

C++11出来之前，

boost搞出了更好用的scoped_ptr/shared_ptr/weak_ptr

之后C++11借鉴了boost库中智能指针，

C++11搞出unique_ptr/shared_ptr/weak_ptr

---

unique_ptr模拟实现 (C++)：

template<class T>

class unique_ptr

{ -- -->

public:

unique_ptr(T* ptr)

:_ptr(ptr)

{ }

~unique_ptr()

{

if (_ptr)

{

cout << "delete -> " << _ptr << endl;

delete _ptr;

_ptr = nullptr;

}

}

T& operator*()

{

return *_ptr;

}

T* operator->()

{

return _ptr;

}

// 防拷贝

unique_ptr(auto_ptr<T>& sp) = delete;

unique_ptr<T>& operator=(unique_ptr<T>& up) = delete;

private:

T* _ptr;

};

void Test_unique_ptr()

{

pxt::unique_ptr<int> up1(new int);

//pxt::unique_ptr<int> up2(up1);

}

---

⭐std::shared_ptr与std::weak_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr

std::shared_ptr文档文档

<code>shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源

shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了

---

shared_ptr模拟实现 (C++)：

template<class T>

class shared_ptr

{ -- -->

public:

shared_ptr(T* ptr = nullptr)

:_ptr(ptr)

,_pcount(new int(1))

{ }

void release()

{

if (--(*_pcount) == 0)

{

//cout << "delete -> " << _ptr << endl;

delete _ptr;

delete _pcount;

}

}

~shared_ptr()

{

release();

}

shared_ptr(shared_ptr<T>& sp)

:_ptr(sp._ptr)

, _pcount(sp._pcount)

{

++(*_pcount);

}

// 获取数量

int use_count() const

{

return *_pcount;

}

// 获取指针

T* get() const

{

return _ptr;

}

shared_ptr<T>& operator=(shared_ptr<T>& sp)

{

if (_ptr != sp._ptr)

{

release();

_ptr = sp._ptr;

_pcount = sp._pcount;

++(*_pcount);

}

return *this;

}

T& operator*()

{

return *_ptr;

}

T* operator->()

{

return _ptr;

}

private:

T* _ptr;

int* _pcount;

};

强如shared_ptr也会存在一定的问题需要我们解决，我们在使用shared_ptr的时候一定要注意，不能循环引用

struct ListNode

{

int val;

pxt::shared_ptr<ListNode> prev;

pxt::shared_ptr<ListNode> next;

~ListNode()

{

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

}

};

void Test_shared_ptr()

{

pxt::shared_ptr<ListNode> n1(new ListNode);

pxt::shared_ptr<ListNode> n2(new ListNode);

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

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

// 循环引用

n1->next = n2;

n2->prev = n1;

}

解决方案：

在引用计数的场景下，把节点中的<code>_prev和_next改成weak_ptr就可以了

原理就是，node1->_next = node2;和node2->_prev = node1;时weak_ptr的_next和_prev不会增加node1和node2的引用计数

weak_ptr模拟实现 (C++)：

template<class T>

class weak_ptr

{ -- -->

public:

weak_ptr()

:_ptr(nullptr)

{ }

weak_ptr(const shared_ptr<T>& sp)

:_ptr(sp.get())

{ }

weak_ptr<T>& operator=(const shared_ptr<T>& sp)

{

_ptr = sp.get();

return *this;

}

T& operator*()

{

return *_ptr;

}

T* operator->()

{

return _ptr;

}

private:

T* _ptr;

};

循环引用解决方案：

struct ListNode

{

int val;

pxt::weak_ptr<ListNode> prev;

pxt::weak_ptr<ListNode> next;

~ListNode()

{

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

}

};

---

删除器

shared_ptr设计了一个删除器来解决一些不是new出来的对象的智能指针管理

仿函数的删除器 (C++)：

template<class T>

struct DelArray

{

void operator()(T* ptr)

{

delete[] ptr;

}

};

在增加删除器后，shared_ptr的参数变多了，因此我们还要修改一下shared_ptr的模拟实现

template<class T>

class shared_ptr

{

public:

shared_ptr(T* ptr = nullptr)

:_ptr(ptr)

,_pcount(new int(1))

{ }

template<class D>

shared_ptr(T* ptr ,D del)

: _ptr(ptr)

, _pcount(new int(1))

,_del(del)

{ }

//function<void(T*)> _del;

void release()

{

if (--(*_pcount) == 0)

{

//cout << "delete -> " << _ptr << endl;

//delete _ptr;

_del(_ptr);

delete _pcount;

}

}

// 其他函数.......

private:

T* _ptr;

int* _pcount;

// 提供一个包装器来确定_del的类型

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

// 提供一个缺省参数，确保在没有提供删除器的情况下能正常使用

};

void Test_shared_ptr2()

{

// 定制删除器

pxt::shared_ptr<ListNode> sp1(new ListNode[10], DelArray<ListNode>());

// 也可以通过我们之前学习的Lambda来实现

pxt::shared_ptr<ListNode> sp2(new ListNode[10], [](ListNode* ptr) { delete[] ptr; });

pxt::shared_ptr<ListNode> sp3(new ListNode[10]);

---

📜3. 内存泄漏

内存泄漏：指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费

---

🍁内存泄漏的危害

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死

内存泄漏的原因：

void Function()

{

// 1.内存申请了忘记释放

int* p1 = (int*)malloc(sizeof(int));

int* p2 = new int;

// 2.异常安全问题

int* p3 = new int[10];

Func(); // 如果Func函数抛异常，就会导致 delete[] p3未执行，p3没被释放.

delete[] p3;

}

---

🍂内存泄漏的分类与检测 (了解)

C/C++程序中一般有两种方面的内存泄漏：

堆内存泄漏(Heap leak)

堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一

块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分

内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak系统资源泄漏

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放

掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定

检测内存泄漏：

在linux下内存泄漏检测：linux下几款内存泄漏检测工具

在windows下使用第三方工具：VLD工具说明

其他工具：内存泄漏工具比较

---

🌸如何避免内存泄漏

工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放

ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。采用RAII思想或者智能指针来管理资源有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项出问题了使用内存泄漏工具检测

ps：不过很多工具都不够靠谱，或者收费昂贵

内存泄漏常见解决方案分为两种：

事前预防型。如智能指针等事后查错型。如泄漏检测工具

---

📝4. C++11和boost中智能指针的关系

C++ 98 中产生了第一个智能指针auto_ptrC++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptrC++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版C++ 11，引入了unique_ptr和shared_ptr和weak_ptr

在C++ 11中，需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的

---

📖5. 总结

随着我们对C++智能指针的深入探索，不难发现，这一特性不仅是C++标准库中的一颗璀璨明珠，更是现代C++编程中不可或缺的基石。通过智能指针，我们不仅能够享受到自动内存管理的便利，减少手动管理资源所带来的繁琐和错误风险，还能深刻理解RAII（Resource Acquisition Is Initialization）资源管理模式的精髓，从而在编程实践中更加高效、安全地管理资源

我们共同见证了std::unique_ptr、std::shared_ptr以及std::weak_ptr等智能指针的神奇之处，从它们的设计理念到实际应用，从基本用法到高级技巧，我们一步步深入，逐渐揭开了智能指针的神秘面纱。相信通过本文的学习，你已经对C++智能指针有了更为全面和深入的理解，也能够在自己的编程实践中灵活运用这一强大工具

但是我还是想说，学习之路永无止境。智能指针只是C++浩瀚知识海洋中的一朵浪花，还有更多精彩的内容等待我们去发掘和探索，不断提升自己的编程能力，在编程的世界里创造属于自己的辉煌

希望本文能够为你提供有益的参考和启示，让我们一起在编程的道路上不断前行！

谢谢大家支持本篇到这里就结束了，祝大家天天开心！