建站程序的选择,以3d全景做的网站,中国建设银行网站企业网银,中国建筑集团有限公司官网2024届校园招聘前言#xff1a;
本期#xff0c;我们将要学习的是在c11中新提出的概念——异常指针#xff01; 目录
#xff08;一#xff09;智能指针的引入
#xff08;二#xff09;内存泄漏
1、什么是内存泄漏#xff0c;内存泄漏的危害
2、内存泄漏分类#xff08;了解
本期我们将要学习的是在c11中新提出的概念——异常指针 目录
一智能指针的引入
二内存泄漏
1、什么是内存泄漏内存泄漏的危害
2、内存泄漏分类了解
3、如何检测内存泄漏了解
4、如何避免内存泄漏 三智能指针的使用及原理
1、RAII
2、智能指针的原理
3、std::auto_ptr
4、std::unique_ptr
5、std::shared_ptr
6、weak_ptr
7、删除器
四C11和boost中智能指针的关系
总结 一智能指针的引入 申请的空间即 new 出来的空间在使用结束时需要 delete 掉否则会形成内存碎片。在程序 运行期间new 出来的对象在析构函数中 delete 掉 但是这种方法不能解决所有问题因为有时 候new 发生在某个全局函数里面该方法会给程序员造成精神负担。 此时智能指针就派上了用 场。 使用 智能指针可以很大程度上避免这个问题因为智能指针就是一个类当超出了类的作用域 时类会自动调用析构函数析构函数会自动释放资源。所以智能指针的作用原理就是在函数结 束时自动释放内存空间避免了手动释放内存空间。 下面我们先分析一下下面这段程序有没有什么 内存方面 的问题提示一下注意分析 MergeSort 函数中的问题 int div()
{int a, b;cin a b;if (b 0)throw invalid_argument(除0错误);return a / b;
}
void Func()
{// 1、如果p1这里new 抛异常会如何// 2、如果p2这里new 抛异常会如何// 3、如果div调用这里又会抛异常会如何int* p1 new int;int* p2 new int;cout div() endl;delete p1;delete p2;
}
int main()
{try{Func();}catch (exception e){cout e.what() endl;}return 0;
} 【解释说明】 p1 指针会保持为空指针因为在异常抛出之前指针 p1 尚未被分配一个有效的内存地址。 由于 p1 指针没有被分配有效内存因此在后续代码中删除 p1 是不安全的。 p2 指针同样也不会被分配有效内存因为在 p1 抛出异常后程序流会直接跳转到异常处理块而不会继续执行 p2 的分配。 div() 函数中的异常会被抛出并且在 main() 函数的异常处理块中被捕获。 总之如果在 new int 分配内存的过程中抛出异常指针 p1 和 p2 将保持为未初始化状态分配的内存将无法释放会导致内存泄漏。 二内存泄漏 1、什么是内存泄漏内存泄漏的危害 什么是内存泄漏 内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内 存泄漏并不是指内存在物理上的消失而是应用程序分配某段内存后因为设计错误失去了对 该段内存的控制因而造成了内存的浪费。 内存泄漏的危害 长期运行的程序出现内存泄漏影响很大如操作系统、后台服务等等出现 内存泄漏会导致响应越来越慢最终卡死。 void MemoryLeaks()
{// 1.内存申请了忘记释放int* p1 (int*)malloc(sizeof(int));int* p2 new int;// 2.异常安全问题int* p3 new int[10];Func(); // 这里Func函数抛异常导致 delete[] p3未执行p3没被释放.delete[] p3;
} 【解释说明】 在上述代码中涉及到了几种内存泄漏和异常安全问题。我简单的分析一哈 内存申请但忘记释放 在以下行中使用了 malloc 来分配内存但是没有相应的 free 来释放内存 int* p1 (int*)malloc(sizeof(int)); 同样在以下行中使用了 new 来分配内存但没有相应的 delete 来释放内存 int* p2 new int; 这些内存分配未被释放会导致内存泄漏即使程序结束也不会释放这些分配的内存。 异常安全问题 在以下行中使用 new 来分配一个整数数组但没有相应的 delete[] 来释放内存 int* p3 new int[10]; 在 Func() 函数内部发生异常时delete[] p3 不会被执行导致在函数返回时出现内存泄漏。 异常引发的内存泄漏 在 Func() 函数中如果发生异常delete p1 和 delete p2 不会被执行导致 p1 和 p2 分配的内存没有被释放。 为了解决这些问题大家在平时写代码时需要 在适当的时候使用 free 或 delete 来释放内存以避免内存泄漏。在分配内存之后确保使用 try 块以便在异常发生时可以释放已分配的内存。在异常处理时要小心确保不会重复释放已经释放过的内存。 总之要编写健壮的代码需要注意资源管理和异常处理以确保内存泄漏和其他异常问题最小化。 2、内存泄漏分类了解 C/C 程序中一般我们关心两种方面的内存泄漏 堆内存泄漏 (Heap leak) 堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一 块内存用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分 内存没有被释放那么以后这部分空间将无法再被使用就会产生Heap Leak。 系统资源泄漏 指程序使用系统分配的资源比方套接字、文件描述符、管道等没有使用对应的函数释放 掉导致系统资源的浪费严重可导致系统效能减少系统执行不稳定 3、如何检测内存泄漏了解 在 linux 下内存泄漏检测Linux 下检测内存泄漏的工具 在 windows 下使用第三方工具VLD工具说明 其他工具内存泄漏工具比较 4、如何避免内存泄漏 1. 工程前期良好的设计规范养成良好的编码规范申请的内存空间记着匹配的去释放。 ps 这个理想状态。但是如果碰上异常时就算注意释放了还是可能会出问题。需要下一条智能指针来管理才有保证。 2. 采用 RAII 思想或者智能指针来管理资源。 3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。 4. 出问题了使用内存泄漏工具检测。 ps 不过很多工具都不够靠谱或者收费昂贵。 【小结】 内存泄漏非常常见解决方案分为两种 1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。 三智能指针的使用及原理 1、RAII RAII Resource Acquisition Is Initialization 是一种 利用对象生命周期来控制程序资源 如内存、文件句柄、网络连接、互斥量等等的简单技术。 在对象构造时获取资源 接着控制对资源的访问使之在对象的生命周期内始终保持有效 最后在 对象析构的时候释放资源 。借此我们实际上把管理一份资源的责任托管给了一个对象。这种做 法有两大好处 不需要显式地释放资源。 采用这种方式对象所需的资源在其生命期内始终保持有效 此时针对上面我们给出的代码给出 使用RAII思想设计的SmartPtr类 的解决方法
// 使用RAII思想设计的SmartPtr类
templateclass T
class SmartPtr {
public:SmartPtr(T* ptr nullptr): _ptr(ptr){}~SmartPtr(){if (_ptr)cout delete: _ptr endl;delete _ptr;}private:T* _ptr;
};
int div()
{int a, b;cin a b;if (b 0)throw invalid_argument(除0错误);return a / b;
}
void Func()
{SmartPtrint sp1(new int);SmartPtrint sp2(new int);cout div() endl;
}int main()
{try {Func();}catch (const exception e){cout e.what() endl;}return 0;
}
输出展示 【解释说明】
上诉这样的做法此时申请的资源不是自己去进行管理而是交给智能指针去管即用这个智能指针去构造一个智能指针对象
针对在前面提到的 p1、p2以及div系统调用这三种情况我们此时在分析一下看在这样的场景下是怎么样的
根据输出展示的效果我们可以发现都是正常的释放。那此时有小伙好奇我们没有delete为什么就释放了呢其实是因为这样的 sp1和sp2 都是局部对象局部对象出了作用域就会调用它的析构函数
如果sp1抛异常了
这个new抛异常就不会进到构造函数里面去因为这个new是实参嘛实参会先调用newnew调用operator new抛异常了是不是直接就走了因此不需要释放资源什么的
如果sp2抛异常了
如果第二个抛异常说起来此处抛异常是一下直接跳到catch区的地方。实际上呢他会先结束这个栈帧里面对象就会调用析构函数调用析构函数就把SP2管理的这个资源给释放了
如果div()抛异常了
再看如果 div 抛异常跟上述一样它会结束这个函数这些局部对象就会调用虚构函数就完成释放了。 2、智能指针的原理 上述的 SmartPtr 还不能将其称为智能指针因为它还不具有指针的行为。指针可以解引用也可 以通过- 去访问所指空间中的内容因此 AutoPtr 模板类中还得需要将 * 、 - 重载下才可让其 像指针一样去使用 。 T operator*()
{return *_ptr;
}T* operator-()
{return _ptr;
}
此时我们就可以像指针一样的正常使用 总结一下智能指针的原理 1. RAII特性 2. 重载operator*和opertaor-具有像指针一样的行为。 3、std::auto_ptr
auto_ptr 文档介绍 auto_ptr 是 C98 标准中引入的一种智能指针用于管理动态分配的内存资源。它提供了一种简单的所有权转移机制允许将资源所有权从一个 auto_ptr 实例转移到另一个实例。 以下是一些关于 auto_ptr 的重要事项 所有权转移 auto_ptr 允许通过赋值操作将资源所有权从一个实例转移到另一个实例。这意味着一旦将资源赋值给另一个 auto_ptr 原始的 auto_ptr 将不再拥有该资源
int main()
{auto_ptrint ptr1(new int(5));auto_ptrint ptr2;ptr2 ptr1; // 所有权转移//cout *ptr2 endl; // 输出 5cout *ptr1 endl; // 错误ptr1 不再拥有指针已经转移给了 ptr2return 0;
}
输出展示 【解释说明】
在上述代码中ptr1 拥有一个动态分配的 int 类型指针并将其赋值给了 ptr2因为 auto_ptr 的所有权转移特性此时 ptr1 不再拥有指针而是将所有权转移到了 ptr2。因此尝试使用 ptr1 解引用会导致未定义行为。 空悬指针问题 auto_ptr 存在空悬指针dangling pointer问题即在资源所有权转移后原始 auto_ptr 会变为空指针但资源可能仍然被另一个 auto_ptr 使用可能导致不可预测的行为。
int main()
{auto_ptrint ptr(new int(5));if (true) {auto_ptrint otherPtr ptr;//...}cout *ptr endl; // 输出不确定的值可能导致程序崩溃return 0;
} 输出展示 【解释说明】
在上述代码中ptr 拥有一个动态分配的 int 类型指针。然后这个指针被转移给了 otherPtr在 if 语句块结束后otherPtr超出了作用域释放了指针并将其设置为 nullptr此时ptr 成为了悬空指针访问它将导致未定义行为。 【小结】 C 引用了 智能指针 auto_ptr 以帮助自动完成这个过程 。随后的编程体验尤其是使用 STL 表 明需要有更精致的机制。基于程序员的编程体验和BOOST 库提供的解决方案 C11 摒弃了 auto_ptr并新增了三种智能指针 unique_ptr、shared_ptr和weak_ptr 。所有新增的智能指针 都能与STL 容器和移动语义协同工作。 4、std::unique_ptr unique_ptr文档 由于 auto_ptr 存在这些问题它在 C11 标准中被弃用。在现代 C 中推荐使用 unique_ptr来代替 auto_ptr 。unique_ptr提供了更好的语义和安全性同时支持移动语义和自定义删除器使得资源管理更加灵活可靠。 unique_ptr 的实现原理简单粗暴的防拷贝下面简化模拟实现了一份 UniquePtr 来了解它的原 理 templateclass Tclass unique_ptr{public:unique_ptr(T* ptr):_ptr(ptr){}unique_ptr(unique_ptrT ap):_ptr(ap._ptr){ap._ptr nullptr;}~unique_ptr(){if (_ptr){cout delete: _ptr endl;delete _ptr;}}// 像指针一样使用T operator*(){return *_ptr;}T* operator-(){return _ptr;}//c11 思路语法直接支持unique_ptr(const unique_ptrT up) delete;unique_ptrT operator(const unique_ptrT up) delete;//c98思路只声明不实现但是用的人可能会在外面强行定义所以可以声明为私有/*private:unique_ptr(const unique_ptrT up);*/private:T* _ptr;};void Test_unique(){unique_ptrint up1(new int);unique_ptrint up2(up1);} 输出展示 当我们使用编译器自带的看效果咋样 【解释说明】 尝试复制构造 std::unique_ptr将会编译错误问题在于 unique_ptr 是独占所有权的智能指针。这意味着一个 unique_ptr 只能拥有一个资源而且不允许通过常规的复制构造函数来复制它可以使用 move 来将资源所有权从一个 unique_ptr 移动到另一个但是直接的复制构造是不被允许的。 代码修改 【解释说明】 在这个修正后的代码中move 函数将 up1 中的资源所有权转移到了 up2避免了编译错误。总之错误是由于 unique_ptr 的独占所有权特性引起的。它只允许资源的唯一所有者因此无法通过常规的复制构造函数来复制 unique_ptr 。要转移资源所有权需要使用 move 函数。 5、std::shared_ptr shared_ptr 文档 引入 shared_ptr 是为了解决资源管理中的共享所有权问题。在许多情况下多个指针需要共同拥有同一资源而且需要确保资源在最后一个使用它的指针释放后才被销毁。shared_ptr 提供了一个智能指针实现允许多个指针共享对资源的所有权同时确保资源的安全释放。 shared_ptr 的原理是通过引用计数的方式来实现多个 shared_ptr 对象之间共享资源 。例如 老师晚上在下班之前都会通知让最后走的学生记得把门锁下。 1. shared_ptr在其内部给每个资源都维护了着一份计数用来记录该份资源被几个对象共 享。 2. 在对象被销毁时(也就是析构函数调用)就说明自己不使用该资源了对象的引用计数减 一。 3. 如果引用计数是0就说明自己是最后一个使用该资源的对象必须释放该资源 4. 如果不是0就说明除了自己还有其他对象在使用该份资源不能释放该资源否则其他对 象就成野指针了。 templateclass Tclass shared_ptr{public:shared_ptr(T* ptr):_ptr(ptr),_pcount(new int(1)),_pmtx(new mutex){}shared_ptr(const shared_ptrT sp):_ptr(sp._ptr),_pcount(sp._pcount),_pmtx(sp._pmtx){AddRef();}void Release(){_pmtx-lock();bool flag false;if (--(*_pcount) 0 _ptr){cout delete: _ptr endl;delete _ptr;delete _pcount;flag true;}_pmtx-unlock();if (flag true){delete _pmtx;}}void AddRef(){_pmtx-lock();(*_pcount);_pmtx-unlock();}shared_ptrT operator (const shared_ptrT sp){if (_ptr ! sp._ptr) //防止自己给自己赋值{Release();_ptr sp._ptr;_pcount sp._pcount;_pmtx sp._pmtx;AddRef();}return *this;}int use_count(){return *_pcount;}~shared_ptr(){Release();}// 像指针一样使用T operator*(){return *_ptr;}T* operator-(){return _ptr;}T* get() const{return _ptr;}private:T* _ptr;int* _pcount;mutex* _pmtx;}; 输出展示 【解释说明】 上述代码展示了一个简化版的 C11 shared_ptr 的实现。这是一个模板类用于管理动态分配的内存并实现了共享所有权的功能实现方法是使用引用计数技术即记录指向同一动态分配内存的共享指针的数量并在最后一个指针被销毁时释放内存为了保证线程安全使用了互斥锁来同步计数器的增加和减少操作另外为了使得共享指针可以像普通指针一样使用还提供了重载解引用运算符和成员访问运算符。 shared_ptr的线程安全问题 通过下面的程序我们来测试 shared_ptr 的线程安全问题。需要注意的是 shared_ptr 的线程安全分为两方面 1. 智能指针对象中引用计数是多个智能指针对象共享的两个线程中智能指针的引用计数同时 或--这个操作不是原子的引用计数原来是1了两次可能还是2.这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以智能指针中引用计数、--是需要加锁的也就是说引用计数的操作是线程安全的。 2. 智能指针管理的对象存放在堆上两个线程中同时去访问会导致线程安全问题。 代码展示 struct Date{int _year 0;int _month 0;int _day 0;~Date(){}};void SharePtrFunc(zp::shared_ptrDate sp, size_t n, mutex mtx){cout sp.get() endl;for (size_t i 0; i n; i){// 这里智能指针拷贝会计数智能指针析构会--计数这里是线程安全的。zp::shared_ptrDate copy(sp);// 这里智能指针访问管理的资源不是线程安全的。所以我们看看这些值两个线程了2n//次但是最终看到的结果并一定是加了2n{unique_lockmutex lk(mtx);copy-_year;copy-_month;copy-_day;}}}void test_shared_safe(){zp::shared_ptrDate p(new Date);cout p.get() endl;const size_t n 50000;mutex mtx;thread t1(SharePtrFunc, ref(p), n, ref(mtx));thread t2(SharePtrFunc, ref(p), n, ref(mtx));t1.join();t2.join();cout p.use_count() endl;cout p-_year endl;cout p-_month endl;cout p-_day endl;} 输出展示 当我们不进行加锁操作时 当我们进行加锁操作时 shared_ptr的循环引用 接下来我们先给出代码在来进行分析解释 struct ListNode{int _data;zp::shared_ptrListNode _prev;zp::shared_ptrListNode _next;~ListNode(){ cout ~ListNode() endl; }};void Test_cycle(){zp::shared_ptrListNode node1(new ListNode);zp::shared_ptrListNode node2(new ListNode);cout node1.use_count() endl;cout node2.use_count() endl;node1-_next node2;node2-_prev node1;cout node1.use_count() endl;cout node2.use_count() endl;}输出展示 【解释说明】 1. node1和node2两个智能指针对象指向两个节点引用计数变成1我们不需要手动 delete。 2. node1的_next指向node2node2的_prev指向node1引用计数变成2。 3. node1和node2析构引用计数减到1但是_next还指向下一个节点。但是_prev还指向上 一个节点。 4. 也就是说_next析构了node2就释放了。 5. 也就是说_prev析构了node1就释放了。 6. 但是_next属于node的成员node1释放了_next才会析构而node1由_prev管理_prev 属于node2成员所以这就叫循环引用谁也不会释放。 由于存在循环引用的问题当程序退出 Test_cycle() 时两个节点的引用计数不会降为0因此它们的析构函数不会被调用。这意味着析构函数中的输出语句不会被执行可能导致内存泄漏的风险。 为了避免循环引用问题可以将 _prev和 _next成员变量为 weak_ptr它是shared_ptr的一种弱引用不会增加引用计数。这样在循环链表中使用 weak_ptr 来打破强引用关系防止循环引用导致的内存泄漏。 下面是修复循环引用问题的示例代码 首先我们先手动实现一个 weak_ptr或者使用库里面提供的weak_ptr。在这里我手动的实现了一个 templateclass Tclass weak_ptr{public:weak_ptr():_ptr(nullptr){}weak_ptr(const shared_ptrT sp):_ptr(sp.get()){}T operator*(){return *_ptr;}T* operator-(){return _ptr;}T* get(){return _ptr;}private:T* _ptr;}; 改正后的代码如下 struct ListNode{int _data;zp::weak_ptrListNode _prev;zp::weak_ptrListNode _next;~ListNode(){ cout ~ListNode() endl; }};void Test_cycle(){zp::shared_ptrListNode node1(new ListNode);zp::shared_ptrListNode node2(new ListNode);cout node1.use_count() endl;cout node2.use_count() endl;node1-_next node2;node2-_prev node1;cout node1.use_count() endl;cout node2.use_count() endl;} 输出展示 【解释说明】 在修复后的代码中将 ListNode 结构体中的成员变量 _prev和_next 改为 zp::weak_ptr 类型这样就不会增加对下一个结点的强引用避免了循环引用问题当程序退出 Test_cycle() 函数时node1 和 node2 的引用计数会降为0析构数 ~ListNode() 会被调用相关的内存资源会被正确释放避免了内存泄漏的问题。 6、weak_ptr 在上述的shared_ptr 讲述中我们使用到了有关 weak_ptr。接下来我们正式的对其进行相关介绍。 基本介绍 weak_ptr 是一种不控制对象生命周期的智能指针, 它指向一个 shared_ptr 管理的对象进行该对象的内存管理的是那个强引用的 shared_ptr。weak_ptr只是提供了对管理对象的一个访问手段weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作它只可以从一个 shared_ptr 或另一个 weak_ptr 对象构造, 它的构造和析构不会引起引用记数的增加或减少 weak_ptr是用来解决shared_ptr相互引用时的死锁问题如果说两个shared_ptr相互引用那么这两个指针的引用计数永远不可能下降为0,资源永远不会释放它是对对象的一种弱引用不会增加对象的引用计数和shared_ptr之间可以相互转化shared_ptr可以直接赋值给它它可以通过调用lock函数来获得shared_ptr 接下来我们通过代码简单的了解一下 class B;
class A
{
public:shared_ptrB pb_;~A(){cout A delete\n;}
};class B
{
public:shared_ptrA pa_;~B(){cout B delete\n;}
};void fun()
{shared_ptrB pb(new B());shared_ptrA pa(new A());pb-pa_ pa;pa-pb_ pb;cout pb.use_count() endl;cout pa.use_count() endl;
}
int main()
{fun();return 0;
} 输出展示 【解释说明】 可以看到fun函数中pa pb之间互相引用两个资源的引用计数为2当要跳出函数时智能指针 papb析构时两个资源引用计数会减一但是两者引用计数还是为1导致跳出函数时资源没有被释放A B的析构函数没有被调用如果把其中一个改为weak_ptr就可以了我们把类A里面的 shared_ptr pb_; 改为weak_ptr pb运行结果如下 这样的话资源B的引用开始就只有1当pb析构时B的计数变为0B得到释放B释放的同时也会使A的计数减一同时pa析构时使A的计数减 一那么A的计数为0A得到释放。 注意 我们不能通过weak_ptr直接访问对象的方法应该先把它转化为shared_ptr 7、删除器 如果不是 new 出来的对象如何通过智能指针管理呢其实 shared_ptr 设计了一个删除器来解决这 个问题 1.定义 智能指针删除器deleter是指在智能指针析构时执行的自定义操作删除器可以在释放智能指针所管理的资源时执行额外的清理工作或自定义逻辑。 下面是一个使用 Lambda 表达式作为删除器的示例 int main()
{int* p new int(10);std::shared_ptrint sp(p, [](int* ptr) { std::cout deleting pointer ptr std::endl; delete ptr; });// 输出共享指针的引用计数std::cout sp use_count: sp.use_count() std::endl;// 手动将共享指针的引用计数减 1sp.reset();return 0;
}输出展示 【解释说明】 上述代码创建了一个指向整型变量 p 的共享指针并使用删除器 Lambda 表达式来输出删除对象的地址和释放堆上分配的内存在 sp.reset() 调用后引用计数变为零并且删除器被调用以释放内存。 四C11和boost中智能指针的关系 首先C11引入了标准库中的智能指针包括std::shared_ptr和std::unique_ptr。这些智能指针提供了管理资源所有权的机制能够自动进行内存管理避免了手动释放资源的麻烦。C11的智能指针是通过引入新的语言特性和库支持来实现的。 Boost是一个流行的C扩展库它提供了大量的高质量、经过广泛测试和使用的 C代码。在C11标准引入智能指针之前Boost已经提供了自己的智能指针库包括boost::shared_ptr和boost::scoped_ptr等。这些智能指针在C社区中被广泛使用并受到了高度赞誉。 实际上C11标准库中的智能指针是受到Boost智能指针的影响和启发。C11标准中的std::shared_ptr和std::unique_ptr的设计和功能基本上与Boost中的boost::shared_ptr和boost::scoped_ptr相当相似。C11智能指针还引入了一些新的特性和改进例如移动语义和自定义删除器等以提供更好的性能和灵活性。 总结 到此关于智能指针的讲解便全部结束了。接下来简单的回顾并总结一下本文 智能指针是一种用于自动管理动态分配资源的指针。它提供了自动化的内存管理可以减少内存泄漏和悬挂指针等常见的资源管理问题。 常见的智能指针类型 std::shared_ptr允许多个指针共享同一块内存资源采用引用计数的方式进行内存管理。std::unique_ptr独占指针保证只有一个指针可以访问资源具有移动语义可用于实现所有权的传递。std::weak_ptr弱引用指针用于解决std::shared_ptr循环引用导致的资源泄漏问题。 智能指针的优点
自动释放资源智能指针通过析构函数自动释放所管理的资源避免了手动释放资源的繁琐过程。避免内存泄漏智能指针使用引用计数或独占所有权的方式确保资源在不再被使用时正确释放避免了内存泄漏问题。提高安全性智能指针可以减少悬挂指针和野指针的问题提高程序的安全性和稳定性。 以上便是本文的全部内容感谢大家的观看与支持
