C++ 智能指针详解

C++智能指针使用总结听语音∙∙|∙浏览：1385∙|∙更新：2015-04-24 20:27C++提供了4种智能指针用于对分配的内存进行自动释放，这些智能指针如下：auto_ptr、unique_ptr、shared_ptr、weak_ptr。

其中auto_ptr在C++98标准引入，后三种在C++11标准中加入。

而auto_ptr已经被C++11所摒弃，建议使用后三种智能指针，这4种智能指针使用模板(template)实现。

在此总结下个人对这4种智能指针肤浅认识。

工具/原料∙GNU GCC g++ 4.8.1 C++编译器∙C++智能指针简介.1.C++智能指针是行为类似于指针的类对象。

它使用设计模式中的代理模式，代理了原始“裸”指针的行为，为指针添加了更多更有用的特性。

.C++引入异常机制后，智能指针由一种技巧升级为一种非常重要的技术，因为如果没有智能指针，程序员必须保证new对象能在正确的时机delete，四处编写异常捕获代码释放资源，而智能指针则可以在退出作用域时——不管是正常离开或是因异常离开——总调用delete来析构在堆栈上动态分配的对象。

.因为C++异常处理的真正功能在于它具有为异常抛掷前构造的所有局部对象(那么智能指针对象也适用)自动调用析构函数的能力（C++异常机制不仅仅在于它能够处理各种不同类型的异常）。

所以在异常退出智能指针对象作用域时，总能由C++异常机制调用析构函数释放在堆栈上动态分配的对象。

.当然，正常退出对象（智能指针对象也属于此列）作用域也会自动调用析构函数释放在堆栈上动态分配的对象。

.由此可知，将“裸”指针包装成智能指针对象可以实现动态分配的内存对象的自动释放。

.而且C++智能指针对象可以像原指针那样直接使用运算符，如赋值运算符'='，指针运算符'->'，解引用运算符'*'。

这点可以从下面的”shared_ptr智能指针--shared_ptr模板类摘要“部分可以印证。

C++标准库智能指针(std::auto_ptr)智能指针两大特性：1.构造栈对象的生命期控制堆上构造的对象的生命期2.通过release来保证auto_ptr对对象的独权.另必须使用显示构造文章结构：一、剖析C++标准库智能指针(std::auto_ptr)1.Do you Smart Pointer?2.std::auto_ptr的设计原理3.std::auto_ptr高级使用指南4.你是否觉得std::auto_ptr还不够完美?---------------------------------------------------------------------一、剖析C++标准库智能指针(std::auto_ptr)1.Do you Smart Pointer?Smart Pointer,中文名：智能指针, 舶来品?不可否认,资源泄露(resource leak)曾经是C++程序的一大噩梦.垃圾回收机制(Garbage Collection)一时颇受注目.然而垃圾自动回收机制并不能满足内存管理的即时性和可视性,往往使高傲的程序设计者感到不自在.况且,C++实现没有引入这种机制.在探索中,C++程序员创造了锋利的"Smart Pointer".一定程度上,解决了资源泄露问题.也许,经常的,你会写这样的代码：//x拟为class:// class x{// public:// int m_Idata;// public:// x(int m_PARAMin):m_Idata(m_PARAMin){}// void print(){ cout<<m_Idata<<endl; }// .....// }//void fook(){x* m_PTRx = new A(m_PARAMin);m_PTRx->DoSomething(); //#2delete m_PTRx;}是的,这里可能没什么问题.可在复杂、N行、m_PTRclassobj所指对象生命周期要求较长的情况下,你能保证你不会忘记delete m_PTRclassobj吗?生活中,我们往往不应该有太多的口头保证,我们需要做些真正有用的东西.还有一个更敏感的问题：异常.假如在#2方法执行期异常发生,函数执行终止,那么new出的对象就会泄露.于是,你可能会说：那么就捕获异常来保证安全性好了.你写这样的程式：void fook(){A* m_PTRx = new A(m_PARAMin);try{m_PTRx->DoSomething();}catch(..){delete m_PTRx;throw;}delete m_PTRx;}哦!天哪!想象一下,你的系统,是否会象专为捕获异常而设计的.一天,有人给你建议:"用Smart Pointer,那很安全.".你可以这样重写你的程序：void fook(){auto_ptr<x> m_SMPTRx(new x(m_PARAMin));m_SMPTRx->DoSomething();}OK!你不太相信.不用delete吗?是的.不用整天提心吊胆的问自己:"我全部delete了吗?",而且比你的delete策略更安全.然后,还有人告诉你,可以这样用呢：ok1.auto_ptr<x> m_SMPTR1(new x(m_PARAMin));auto_ptr<x> m_SMPTR2(m_SMPTR1); //#2May be you can code #2 like this :auto_ptr<x> m_SMPTR2;m_SMPTR2 = m_SMPTR1;ok2.auto_ptr<int> m_SMPTR1(new int(32));ok3.auto_ptr<int> m_SMPTR1;m_SMPTR1 = auto_ptr<int>(new int(100));也可以：auto_ptr<int> m_SMPTR1(auto_ptr<int>(new int(100)));ok4.auto_ptr<x> m_SMPTR1(new x(m_PARAMin));m_SMPTR1.reset(new x(m_PARAMin1));ok5.auto_ptr<x> m_SMPTR1(new x(m_PARAMin));auto_ptr<x> m_SMPTR2(m_SMPTR.release());cout<<(*m_SMPTR2).m_Idata<<endl;ok6.auto_ptr<int> fook(){return auto<int>(new int(100));}ok7.............and so on但不可这样用：no1.char* chrarray = new char[100];strcpy(chrarray,"I am programming.");auto_ptr<char*> m_SMPTRchrptr(chrarray);//auto_ptr并不可帮你管理数组资源no2.vector<auto_ptr<x>> m_VECsmptr;m_VECsmptr.push_back(auto_ptr<int>(new int(100)));//auto_ptr并不适合STL内容.no3.const auto_ptr<x> m_SMPTR1(new x(100));//所有权问题，不能用const 类型auto_ptr<x> m_SMPTR(new x(200));no4.x m_OBJx(300);auto_ptr<x> m_SMPTR(&m_OBJx);//不支持栈资源的释放，因为析构中用的是deleteno5x* m_PTR = new x(100);auto_ptr<x> m_SMPTR = m_pTR;//禁止隐式转换no6..........and so on预先提及所有权的问题,以便下面带着疑问剖析代码?power1.auto_ptr<x> m_SMPTR1(new x(100));auto_ptr<x> m_SMPTR2 = m_SMPTR1;m_SMPTR2->print();//输出：100.m_SMPTR1->print();//!! 非法的.power2.auto_ptr<x> m_SMPTR(new x(100));auto_ptr<x> returnfun(auto_ptr<x> m_SMPTRin){return m_SMPTRin;}auto_ptr<x> = returnfun(m_SMPTR); //#5//在上面的#5中,我要告诉你对象所有权转移了两次.//什么叫对象所有权呢?2. std::auto_ptr的设计原理上面的一片正确用法,它们在干些什么?一片非法,它们犯了什么罪?一片什么所有权转移,它的内部机智是什么?哦!一头雾水?下面我们就来剖析其实现机制.基础知识：a.智能指针的关键技术：在于构造栈上对象的生命期控制堆上构造的对象的生命期.因为在智能指针的内部,存储着堆对象的指针,而且在构析函数中调用delete行为.大致机构如下：x* m_PTRx = new x(100);//#1template<typename T>auto_ptr{private:T* m_PTR;//维护指向堆对象的指针,在auto_ptr定位后.... //它应该指向#1构造的对象,即拥有所有权.~auto(){ delete m_PTR; }....}b.所有权转移之说上面曾有一非法的程式片段如下：auto_ptr<x> m_SMPTR1(new x(100));auto_ptr<x> m_SMPTR2 = m_SMPTR1;m_SMPTR2->print();//输出：100.m_SMPTR1->print();//!! 非法的.按常理来说,m_SMPTR->print();怎么是非法的呢?那是因为本来,m_SMPTR1维护指向new x(100)的指针,可是m_SMPTR2 = m_SMPTR1;auto_ptr内部机制使得m_SMPTR1将对象的地址传给m_SMPTR2,而将自己的对象指针置为0.那么自然m_SMPTR->print();失败.这里程序设计者要负明显的职责的.那么auto_ptr为什么采取这样的策略：保证所有权的单一性.亦保证了系统安全性.如果多个有全权的auto_ptr维护一个对象,那么在你消除一个 auto_ptr时,将导致多个auto_ptr的潜在危险.下面我们以SGI-STL的auto_ptr设计为样本(去掉了无关分析的宏),来剖析其原理.#1 template <class _Tp> class auto_ptr {#2 private:#3 _Tp* _M_ptr; //定义将维护堆对象的指针#4 public:#5 typedef _Tp element_type; //相关类型定义#6 explicit auto_ptr(_Tp* __p = 0) __STL_NOTHROW : _M_ptr(__p) {}#7 auto_ptr(auto_ptr& __a) __STL_NOTHROW : _M_ptr(__a.release()) {}#8 template <class _Tp1> auto_ptr(auto_ptr<_Tp1>& __a)__STL_NOTHROW:_M_ptr(__a.release()) {}//#6、#7、#8是auto_ptr构造函数的三个版本.//#6注释：传入对象的指针,构造auto_ptr.explicit关键字:禁止隐式转换.// 这就是ok2正确,而no5(隐式转换)错误的原因.//#7注释：拷贝构造函数.// 传入auto_ptr实例,构造auto_ptr. ok1、ok3使用了这个构造式.// 它是一个很关键的构造函数,在具体情况下,我们再分析 //#8注释：auto_ptr的模板成员,可在继承对象重载的基础上,实现特殊功能.//// 举例：// class A{ public:// virtual void fook(){cout<<"I am programming"<<endl;// /*..........*/ };// class B : public A {// virtual void fook(){ cout<<"I am working"<<endl; // /*...........*/ };// auto_ptr<A> m_SMPTRa(new A(33));//实质：// auto_ptr<B> m_SMPTRb(m_SMPTRa); //基类的指针可以赋给派生类的指针//// auto_ptr<B> m_SMPTRb(new B(44));//实质：// auto_ptr<A> m_SMPTRa(m_SMPTRb); //派生类的指针不可赋给基类的指针//// auto_ptr<A> m_SMPTRa(new B(33)); // ok!// m_SMPTRa->fook()将调用派生类B的fook()// m_SMPTRa->A::fook()将调用基类A的fook()//// auto_ptr<B> m_SMPTRb(new A(33)); // wrong!////#9 auto_ptr& operator=(auto_ptr& __a) __STL_NOTHROW {#10 if (&__a != this) { delete _M_ptr; _M_ptr = __a.release(); } #11 return *this;#12 }#13 template <class _Tp1>#14 auto_ptr& operator=(auto_ptr<_Tp1>& __a) __STL_NOTHROW { #15 if (__a.get() != this->get()) { delete _M_ptr; _M_ptr =__a.release(); }#16 return *this;#16 }//// #9~~#16 两个版本的指派函数.// delete _M_ptr; 在指派前,销毁原维护的对象.// _a.release() ; release操作,详细代码参见#20~~#23. // 用于*this获得被指派对象,// 且将原维护auto_ptr置空.// no3使用了第一种指派.// 而权限转移正是_a.release()的结果.#17 ~auto_ptr() __STL_NOTHROW { delete _M_ptr; }//构析函数.消除对象.注意这里对对象的要求!#17 _Tp& operator*() const __STL_NOTHROW { return *_M_ptr; } #18 _Tp* operator->() const __STL_NOTHROW { return _M_ptr; } #19 _Tp* get() const __STL_NOTHROW { return _M_ptr; }//// 操作符重载.// #17注释：提领操作(dereference),获得对象. 见ok5用法.// #18注释：成员运算符重载,返回对象指针.// #19注释：普通成员函数.作用同于重载->运算符//#20 _Tp* release() __STL_NOTHROW {#21 _Tp* __tmp = _M_ptr;#22 _M_ptr = 0;#23 return __tmp; }//上面已经详解#24 void reset(_Tp* __p = 0) __STL_NOTHROW {#25 delete _M_ptr;#26 _M_ptr = __p; }////传入对象指针,改变auto_ptr维护的对象// 且迫使auto_ptr消除原来维护的对象// 见ok3用法.// According to the C++ standard, these conversions are required. Most// present-day compilers, however, do not enforce that requirement---and,// in fact, most present-day compilers do not support the language// features that these conversions rely on.//下面这片段用于类型转化,目前没有任何编译器支持//具体技术细节不诉.#ifdef __SGI_STL_USE_AUTO_PTR_CONVERSIONS#27 private:#28 template<class _Tp1>#29 struct auto_ptr_ref { _Tp1* _M_ptr; auto_ptr_ref(_Tp1* __p) : _M_ptr(__p) {}};#30 public:#31 auto_ptr(auto_ptr_ref<_Tp> __ref) __STL_NOTHROW: _M_ptr(__ref._M_ptr) {}#32 template <class _Tp1>#33 operator auto_ptr_ref<_Tp1>() __STL_NOTHROW#34 { return auto_ptr_ref<_Tp>(this->release()); }#35 template <class _Tp1> operator auto_ptr<_Tp1>() __STL_NOTHROW #36 { return auto_ptr<_Tp1>(this->release()); }#37 #endif /* __SGI_STL_USE_AUTO_PTR_CONVERSIONS */#38 };OK!就是这样了.正如上面原理介绍处叙说,你需要正视两大特性：1.构造栈对象的生命期控制堆上构造的对象的生命期2.通过release来保证auto_ptr对对象的独权.在我们对源码分析的基础上,重点看看：no系列错误在何处?no1.我们看到构析函数template<class _Tp>~auto_ptr() _STL_NOTHROW{ delete _M_ptr; }所以它不能维护数组,维护数组需要操作：delete[] _M_ptr;no2.先提部分vector和auto_ptr代码：a.提auto_ptr代码auto_ptr(auto_ptr& __a) __STL_NOTHROW : _M_ptr(__a.release()) {} b.提vector代码Part1:void push_back(const _Tp& __x) {if (_M_finish != _M_end_of_storage) {construct(_M_finish, __x);++_M_finish;}else_M_insert_aux(end(), __x);}Part2:template <class _T1, class _T2>inline void construct(_T1* __p,//++++++++++++++++++++++++++++++++// const _T2& __value) { +//++++++++++++++++++++++++++++++++// new (__p) _T1(__value); +//++++++++++++++++++++++++++++++++}Part3.template <class _Tp, class _Alloc>voidvector<_Tp, _Alloc>::_M_insert_aux(iterator __position,//++++++++++++++++++++++++++++++++// const _Tp& __x) ++//++++++++++++++++++++++++++++++++{if (_M_finish != _M_end_of_storage) {construct(_M_finish, *(_M_finish - 1));++_M_finish;//++++++++++++++++++++++++++++++++// _Tp __x_copy = __x; +//++++++++++++++++++++++++++++++++copy_backward(__position, _M_finish - 2, _M_finish - 1); *__position = __x_copy;}else {const size_type __old_size = size();const size_type __len = __old_size != 0 ? 2 * __old_size : 1; iterator __new_start = _M_allocate(__len);iterator __new_finish = __new_start;__STL_TRY {__new_finish = uninitialized_copy(_M_start, __position, __new_start);construct(__new_finish, __x);++__new_finish;__new_finish = uninitialized_copy(__position, _M_finish, __new_finish);}__STL_UNWIND((destroy(__new_start,__new_finish),_M_deallocate(__new_start,__len)));destroy(begin(), end());_M_deallocate(_M_start, _M_end_of_storage - _M_start);_M_start = __new_start;_M_finish = __new_finish;_M_end_of_storage = __new_start + __len;}}从提取的vector代码,Part1可看出,push_back的操作行为.兵分两路,可是再向下看,你会发现,无一例外,都通过const _Tp& 进行拷贝行为,那么从auto_ptr提出的片段就派上用场了.可你知道的,auto_ptr总是坚持对对象的独权.那必须修改原来维护的对象,而vector行为要求const _Tp&,这样自然会产生问题.一般编译器是可以发觉这种错误的.其实,STL所有的容器类都采用const _Tp&策略.//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ++ 看了sutter和Josuttis的两篇文章中,都提及： ++ STL容器不支持auto_ptr原因在于copy的对象只是获得所有权的对象, ++ 这种对象不符合STL的要求.可是本人总感觉即时不是真正的复制对象,++ 但我用vector<auto_ptr<x> >的目的就在于维护对象,并不在乎 ++ 所谓的完全对象.而且我用自己写的Smart Pointer配合STL容器工作, ++ 很正常.那需要注意的仅仅是const问题. ++ +//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +no3.这个也是auto_ptr隐含的所有权问题引起的.const auto_ptr不允许修改.随便提及：const对象不代表对象一点不可以改变.在两种const语义下,都有方法修改对象或对象内部指针维护的对象或其它资源.no4.再看auto_ptr的构析函数.delete不可以消除栈上资源.no5.依赖传入对象指针的构造函数被声明为explicit,禁止隐式转换.3.auto_ptr高级使用指南a.类成员auto_ptr,禁止构造函数以构建"完全对象"Programme1:struct Structx{int m_Idata;char m_CHRdata;/* and so on */};出于对象编程的理念,我们将Structx打造成包裹类：class StructWrapper{private:Structx* m_STRTxptr;public:StructWrapper():m_STRTxptr(new Structx){}~StructWrapper(){delete m_SMRTxptr; }public:void Soperator1(){ /* 针对Structx对象的特性操作 */}void Soperator2(){ /* 针对Structx对象的特性操作 */} /* and so on */};Programme2:class StructWrapper{private:auto_ptr<Structx> m_SMPTRx;public:StructWrapper():m_SMPTRAx(new Structx){}public:void Soperator1(){ /* 针对Structx对象的特性操作 */}void Soperator2(){ /* 针对Structx对象的特性操作 */} /* and so on */};Programme3:StructWrapper::StructWrapper(const StructWrapper& other): M_SMPTRx(new Struct(*other.m_SMPTRx)) { }StructWrapper& StructWrapper::operator=(const StructWrapper &other){*m_SMPTRx = *other.m_SMPTRx;};处于对构建于堆中的对象(new Structx)智能维护的需要.我们将programme1改造为programme2：不错,对象是可以智能维护了.对于包裹类(StructWrapper)你是否会有这样的构造或指派操作：StructWrapper m_SMPTRWrapper2(m_SMPTRWrapper1);StructWrapper mSMPTRWrapper2 = m_SMPTRWrapper1;那么请注意：当你坦然的来一个：M_SMPTRWrapper1->Soperator1();的时候,系统崩溃了.不必惊讶,所有权还是所有权问题.问一下自己：当programme2默认拷贝构造函数作用时,又调用了auto_ptr的默认构造函数,那么auto_ptr所有的默认行为都遵循独权策略.对,就这样.m_SMPTRWrapper1的对象所有权转移给了m_SMPTRWrapper2.M_SMPTRWrapper1->Soperator1();那么操作变成了在NULL上的.哦!系统不崩溃才怪.那么你需要想,programme3那样利用auto_ptr的提领操作符自己的构造"完全对象".b.利用const关键字,防止不经意的权限转移从上面的叙述,你可看出,所有权转移到处可以酿成大祸.而对于一般应用来说,独权又是很好的安全性策略.那么我们就用const来修饰auto_ptr,禁止不经意的错误.当然上面提及：并不代表auto_ptr是不可修改的.处于需要,从两种const语义,你都可实现修改.然,你还希望在函数传入传出auto_ptr那么你可传递auto_ptr的引用,那就万无一失了: void fook(const auto_ptr<x>& m_PARAMin);在返回后赋予其它时,使用引用是不行的.你得用指针.因为引用无论作为lvalue还是rvaluev,都会调用构造或指派函数.4.你是否觉得std::auto_ptr还不够完美在实践中,std::auto_ptr能满足你的需求吗?Andrei Alexandrescu在一篇文章中,提及：有关Smart Pointer的技术就像巫术.Smart Pointer作为C++垃圾回收机制的核心,它必须足够强大的、具有工业强度和安全性.但为了可一劳永逸我们还需要披荆斩棘继续探索.下面在需求层面上,我们思索一下我们的智能指针还需要些什么?a. std::auto_ptr 能够处理数组吗?我们可以用智能指针来管理其它的资源吗?譬如一个线程句柄、一个文件句柄 and so on !b. 对于我们的对象真的永远实行独权政策吗?c. Our 智能指针还需要在继承和虚拟层面上发挥威力 !d. 往往,需要扩展Our 智能指针的功能成员函数来满足动态的需要 !e. 也许,你需要的还很多.智能指针 std::auto_ptr 和shared_ptrauto_ptr 类可以用于管理由 new 分配的单个对象，但是无法管理动态分配的数组（我们通常不会使用数组，而是使用 vector 代替数组）。

c++智能指针的使用案例
C++智能指针是一种特殊的指针类型，可以自动管理对象的内存，避免了手动管理内存的麻烦。

这里给出一些使用C++智能指针的案例： 1. 在函数中使用智能指针
在函数中使用智能指针可以避免内存泄漏的问题。

例如，在一个函数中创建一个对象并返回该对象的智能指针，函数执行完毕后，智能指针会自动销毁对象。

2. 在类中使用智能指针
在类中使用智能指针可以避免手动管理类成员的内存问题。

例如，在一个类中使用智能指针管理一个动态分配的对象，当类的实例被销毁时，智能指针会自动销毁对象。

3. 在多线程环境中使用智能指针
在多线程环境中使用智能指针可以避免多线程操作同一内存块
的问题。

例如，在多个线程中使用智能指针管理同一对象，每个线程都会拥有该对象的独立智能指针，从而避免了竞争条件和死锁等问题。

4. 在异常处理中使用智能指针
在异常处理中使用智能指针可以避免内存泄漏的问题。

例如，在一个函数中使用智能指针管理一个动态分配的对象，当函数抛出异常时，智能指针会自动销毁对象。

总之，C++智能指针可以方便地管理内存，避免内存泄漏和其他
常见的内存问题，值得在C++编程中广泛使用。

- 1 -。

函数参数智能指针是指**使用智能指针作为函数参数**。

智能指针是一种行为类似于指针的类对象，但这种对象还有其他功能，比如可以自动删除指针指向的内存，避免内存泄漏。

使用智能指针作为函数参数可以帮助函数更好地管理内存资源。

在C++中，常见的智能指针有3种：shared_ptr、unique_ptr和weak_ptr。

shared_ptr 是共享式智能指针，多个指针可以共享同一块内存，当一个shared_ptr被销毁时，它会自动删除它所指向的内存，其他shared_ptr也会自动删除。

unique_ptr是独占式智能指针，它会在作用域结束时自动删除它所指向的内存，不能被复制到另一个unique_ptr 中。

weak_ptr是弱引用智能指针，它指向一个由shared_ptr管理的对象，不会增加对象的引用计数，当对象被销毁时，weak_ptr也会自动删除。

在函数参数中使用智能指针有很多好处。

首先，它可以避免内存泄漏，因为智能指针会在适当的时候自动删除内存。

其次，它可以方便地处理动态分配的资源，不需要手动分配和释放内存。

最后，它可以简化代码，因为不需要手动管理内存的生命周期。

需要注意的是，在使用智能指针时要注意避免循环引用的问题。

如果两个智能指针相互引用，会导致内存泄漏。

此外，要注意区分不同类型的智能指针，根据需要选择合适的类型来管理内存资源。

函数参数智能指针介绍函数参数智能指针是指在函数的参数中使用智能指针来管理内存。

智能指针是一种特殊的指针对象，它能够自动管理所指向的内存资源，避免了手动释放内存的麻烦和可能导致的内存泄漏问题。

通过使用函数参数智能指针，可以提高代码的可读性和可维护性，并减少潜在的错误。

为什么使用函数参数智能指针在传统的C/C++编程中，我们通常使用裸指针来传递参数。

这样做存在一些问题，例如：1.内存泄漏：如果在函数中分配了内存，但在函数返回之前忘记释放，就会导致内存泄漏。

2.悬空指针：如果在函数中释放了内存，但在函数返回后仍然使用了指向该内存的指针，就会导致悬空指针问题。

3.多次释放：如果在函数中释放了由外部传入的指针，而该指针在函数外部也被释放了，就会导致多次释放同一块内存的问题。

使用函数参数智能指针可以解决上述问题。

智能指针会在适当的时机自动释放所指向的内存，避免了手动释放内存的麻烦和可能导致的错误。

常见的函数参数智能指针类型在C++中，有几种常见的函数参数智能指针类型，包括：1.std::unique_ptr：独占式智能指针，用于管理独占的内存资源。

它保证了同一时间只有一个指针可以指向所管理的对象，当指针超出范围时，会自动释放所指向的对象。

2.std::shared_ptr：共享式智能指针，用于管理共享的内存资源。

它可以被多个指针共享，当最后一个指针超出范围时，会自动释放所指向的对象。

3.std::weak_ptr：弱引用智能指针，用于解决std::shared_ptr的循环引用问题。

它可以观测一个std::shared_ptr对象，但不会增加对象的引用计数，当所观测的对象被释放后，它会自动失效。

使用函数参数智能指针的示例下面是一个使用函数参数智能指针的示例，展示了如何避免内存泄漏和多次释放的问题。

#include <iostream>#include <memory>void process_data(std::unique_ptr<int> data) {// 在这里对data进行一些处理std::cout << "Data: " << *data << std::endl;}int main() {std::unique_ptr<int> data(new int(10));process_data(std::move(data));// 在这里无需手动释放data指向的内存return 0;}在上面的示例中，我们使用了std::unique_ptr来管理data指向的内存。

智能指针是一种存储指向动态分配（堆）对象指针的类，用于生存期控制，以防止内存泄露。

它通过使用引用计数(referencecount)的技术来实现其功能。

每当创建一个新的智能指针对象时，初始化指针并将引用计数置为1。

当一个对象作为另一个对象的副本而创建时，拷贝构造函数会拷贝指针并增加与之相应的引用计数。

对一个对象进行赋值时，赋值操作符会减少左操作数所指对象的引用计数（如果引用计数减至0，则删除对象），并增加右操作数所指对象的引用计数。

在调用析构函数时，构造函数会减少引用计数（如果引用计数减至0，则删除基础对象）。

这种机制确保了当智能指针对象不再需要时，所指向的基础对象也会被正确地销毁，从而防止了内存泄露。

同时，智能指针还具有其他一些有用的功能，比如自动销毁以及重载->和*操作符等。

C++中的智能指针和内存管理智能指针是C++中的一种重要特性，用于帮助管理内存。

它们能够自动删除所拥有的资源，从而避免内存泄漏和其他内存管理问题。

本文将介绍智能指针的概念、类型和使用方法，并探讨其在内存管理方面的优势。

在C++中，传统的指针使用需要手动分配和释放内存，这往往容易出错。

例如，如果忘记了释放已经分配的内存，就会导致内存泄漏。

为了解决这个问题，C++引入了智能指针的概念。

智能指针是一种类模板，它模拟了指针的行为，但会自动管理指向的资源。

智能指针通过使用RAII（资源获取即初始化）的原则，将资源的所有权绑定到单一对象上。

当这个对象被销毁时，资源也会被自动释放。

C++标准库中提供了几种类型的智能指针：unique_ptr、shared_ptr和weak_ptr。

它们之间的区别在于资源的所有权和引用计数的管理方式。

unique_ptr是一种独占的智能指针，它以独占的方式拥有所指向的对象。

它的特点是在任何时候只有一个unique_ptr可以拥有特定的对象。

当unique_ptr被销毁时，它所拥有的资源也会被释放。

这个特性确保了资源不会被多个指针同时访问，从而避免了悬空指针和内存泄漏的问题。

shared_ptr是一种共享的智能指针，可以允许多个shared_ptr拥有同一个对象。

它使用引用计数的方式管理资源的生命周期。

每当有新的shared_ptr指向一个对象时，引用计数会增加；当没有任何shared_ptr指向对象时，引用计数会减少。

当引用计数降为零时，对象所占用的内存会被释放。

shared_ptr的好处是可以避免多个指针同时释放同一个资源，并且可以跨函数和线程进行传递。

weak_ptr是shared_ptr的一种扩展，它可以避免循环引用导致的内存泄漏问题。

当存在互相引用的shared_ptr时，它们之间的循环引用可能会导致资源无法释放。

为了解决这个问题，可以使用weak_ptr 来建立一个弱引用。

c++智能指针的工作原理
C++智能指针是一种用于管理动态分配的内存的工具。

它们可
以自动进行内存管理，以避免内存泄漏和重复释放的问题。

C++标准库中提供了两种智能指针：std::shared_ptr和
std::unique_ptr。

1. std::shared_ptr：
- 智能指针使用引用计数的方法来管理内存。

它们会记录有
多少个智能指针指向同一块内存。

- 当创建一个std::shared_ptr时，引用计数初始化为1。

- 每次复制或移动std::shared_ptr时，引用计数会递增。

- 当智能指针超出其作用域或被重新分配时，引用计数会递减。

- 当引用计数变为0时，智能指针会自动销毁所管理的内存。

2. std::unique_ptr：
- 智能指针使用独占所有权的方法来管理内存。

它们不允许
多个指针同时指向相同的内存。

- 当创建一个std::unique_ptr时，它会获取对所管理的内存的
独占所有权。

- std::unique_ptr不支持复制，只能通过移动来传递所有权。

- 当智能指针超出其作用域时，它会自动销毁所管理的内存。

无论是std::shared_ptr还是std::unique_ptr，当智能指针超出其
作用域或被重新分配时，它们所管理的内存都会被自动释放。

这样可以避免手动释放内存、内存泄漏和重复释放的问题，提高了代码的可靠性和可维护性。