C++智能指针与enable_shared_from_this机制深度解析

智能指针的引入

int *ptr;

1. 如果使用裸指针分配内存后，忘记手动释放资源，会出现内存泄漏。
2. 如果使用多个裸指针指向同一资源，其中一个指针对资源进行释放，其它指针成为空悬指针，如果再次释放会存在不可预测的错误。

   

   上图中当 sp1 把资源释放后，sp2 成了空悬指针。空悬指针指的是指针所指向的对象已经释放的时候自身却没有被置为 ptr。sp1 通过 free/delete 释放资源的内存时，内存不会立刻被系统回收，而是状态改变为可被其它地方申请的状态。这时当再次操作 sp2，这块内存可能被其它地方申请了，而具体被谁申请了是不确定的，因此可能导致的错误也是不可预测的。
3. 如果程序异常退出时，裸指针的释放资源的代码未能执行，也会造成内存泄漏。

智能指针的分类

不带引用计数的智能指针

不带引用计数的智能指针

2.1 auto_ptr:

#include<memory>int main(){ auto_ptr<int> ptr(new int(6));//定义auto_ptr指针ptr auto_ptr<int> ptr1(ptr); //拷贝构造ptr定义ptr1 *ptr=8;//对空指针ptr赋值会产生不可预料的错误 return 0;}

auto_ptr

template<class _Ty>class auto_ptr{ public: typedef _Ty element_type;
 explicit auto_ptr(_Ty * _Ptr=ptr) noexcept : _Myptr(_Ptr)//初始化列表 { //构造函数 }
 auto_ptr(auto_ptr& _Right) noexcept : _Myptr(_Right.release()) { //拷贝构造函数，会调用release()函数 }  _Ty * release() noexcept { /*使用拷贝构造时，最后一个auto_ptr持有资源， 其余被置为ptr*/  _Ty * _Tmp = _Myptr; _Myptr = ptr; return (_Tmp); }private: _Ty * _Myptr;//指向资源 };

2.2 scoped_ptr

scoped_ptr<int> sp1(new int(6));//初始化sp1指针

scoped_ptr<int> sp2(sp1);//错误，无法拷贝构造

 scoped_ptr<int> sp3(new int(5))//初始化sp2指针 sp1=sp3;//错误，无法赋值

template<class T> class scoped_ptr{private: T * px;  scoped_ptr(scoped_ptr const &);//拷贝构造函数 scoped_ptr & operator=(scoped_ptr const &);//赋值构造函数 public: typedef T element_type; explicit scoped_ptr( T * p = ptr ): px( p ) { } ~scoped_ptr() //析构函数};

2.3 unique_ptr

unique_ptr<int> p1(new int(6));//正确写法unique_ptr<int> p2(p1); //这么写是错误的：// unique_ptr不支持拷贝unique_ptr<int> p3;p3=p2;//这么写是错误的：unique_ptr不支持赋值

template<class _Ty,class _Dx>class unique_ptr: public _Unique_ptr_base<_Ty, _Dx>{ public: typedef _Unique_ptr_base<_Ty, _Dx> _Mybase; typedef typename _Mybase::pointer pointer; typedef _Ty element_type; typedef _Dx deleter_type;
 unique_ptr(unique_ptr&& _Right) noexcept : _Mybase(_Right.release(), _STD forward<_Dx>(_Right.get_deleter())) { // 右值引用的拷贝构造函数 }
 unique_ptr& operator=(unique_ptr&& _Right) noexcept { //提供了右值引用的operator=赋值构造函数 if (this != _STD addressof(_Right)) {  reset(_Right.release()); this->get_deleter() = _STD forward<_Dx> (_Right.get_deleter()); } return (*this); } /* 删除了unique_ptr的拷贝构造和赋值函数，拒绝浅拷贝 */ unique_ptr(const unique_ptr&) = delete; unique_ptr& operator=(const unique_ptr&) = delete; };

1. auto_ptr 进行拷贝构造时，会对之前的 auto_ptr 的资源置 ptr 操作；
2. scoped_ptr 通过私有化了拷贝构造和赋值函数杜绝浅拷贝；
3. unique_ptr 通过删除了拷贝构造和赋值函数函数杜绝浅拷贝，但引入了带右值引用的拷贝构造和赋值函数。

带引用计数的智能指针

智能指针的工作过程

sp1 对象发生析构

sp2 对象也发生析构

资源释放

3.1 shared_ptr

3.2 weak_ptr

enable_shared_from_this 机制

多线程应用场景

//场景代码#include<memory>class ObjectPool:boost::noncopyable{public: shared_ptr<Object> get(const string& key) { shared_ptr<Object> shObject; MutexLockGuard lock(mutex); weak_ptr<Object>& wkObject=object[key]; shObject=wkObject.lock(); //对象存在，提升成功并返回 if(!shObject){ /*对象不存在，提升失败，shOject重新 指向新创建的Object对象， 并绑定回调函数，让对象Oject需要析构时 调用OjectPool对象的成员函数*/ shObject.reset(new Object(key), boost::bind(& ObjectPool::deleteObject,this, _1)); wkObject=shObject; } return shObject; } private: void deleteObject(Object* obj){ /*回调函数，在对象需要析构时调用，从map中 删除对象和对应的key*/ if(obj){ MutexLockGuard lock(mutex); object.erase(obj->key()); } delete obj; } mutable MutexLock mutex; std::map<string,weak_ptr<Object>> object; /*map中不能使用shared_ptr，这会导致Oject对象永远不会被销 毁*/};

shared_ptr<A> getSharedPtr() {  return shared_ptr<A>(this); }

template<class _Ty>class _Ptr_base{ private: element_type * _Ptr{ptr}; // 指向资源的指针 _Ref_count_base * _Rep{ptr}; // 指向资源引用计数的指针};

class __declspec(novtable) _Ref_count_base{ private: _Atomic_counter_t _Uses;//记录资源引用个数 _Atomic_counter_t _Weaks;//记录观察者个数}

class A{ public: A(){} ~A(){}};A *p = new A(); shared_ptr<A> ptr1(p);//调用构造函数shared_ptr<A> ptr2(p);//调用构造函数

方式1：调用构造函数

class A{public: A(){} ~A(){}}A *p = new A(); shared_ptr<A> ptr1(p);//调用构造函数shared_ptr<A> ptr2(ptr1);//调用拷贝构造函数

方式2：调用拷贝构造函数

template<class _Ty>class enable_shared_from_this{ public: mutable weak_ptr<_Ty> _Wptr;//指向资源};

shared_ptr<A> getSharedPtr() {  return shared_from_this(); }

class ObjectPool:boost::noncopyable//为class ObjectPool:public boost::enable_shared_from_this<ObjectPool>， boost::noncopyable{/*...*/};

//改变shared_ptr<Object> get(const string& key){ /*...*/ shObject.reset(new Object(key), boost::bind(&ObjectPool::deleteObject,this,_1)); /*...*/ }//为shared_ptr<Object> get(const string& key){ /*...*/ shObject.reset(new Object(key), boost::bind(&ObjectPool::deleteObject,shared_from_this(),_1)); /*...*/ }

#include<memory>class ObjectPool:public boost::enable_shared_from_this<ObjectPool>， boost::noncopyable{public:shared_ptr<Object> get(const string& key){ shared_ptr<Object> shObject; MutexLockGuard lock(mutex); weak_ptr<Object>& wkObject=object[key]; shObject=wkObject.lock();//对象存在，提升成功并返回 if(!shObject){ /*对象不存在，提升失败，shOject重新指向新创建的 Object对象，并绑定回调函数，让对象Oject需要析构时 调用OjectPool对象的成员函数*/ shObject.reset(new Object(key), boost::bind(& ObjectPool::deleteObject,shared_from_this(), _1)); wkObject=shObject; } return shObject;}private:void deleteObject(Object* obj){ /*回调函数，在对象需要析构时调用，从map中删除对象和对应的key*/ if(obj){ MutexLockGuard lock(mutex); object.erase(obj->key()); } delete obj;}mutable MutexLock mutex;std::map<string,weak_ptr<Object>> object;/*map中不能使用shared_ptr，这会导致Oject对象永远不会被销毁*/};

1. shared_ptr 会增加资源的引用计数，常用于管理对象的生命周期。
2. weak_ptr 不会增加资源的引用计数，常作为观察者用来判断对象是否存活。
3. 使用 shared_ptr 的普通拷贝构造函数会产生额外的引用计数对象，可能导致对象多次析构。使用 shared_ptr 的拷贝构造函数则只影响同一资源的同一引用计数的增减。
4. 当需要返回指向当前对象的 shared_ptr 时，优先使用 enable_shared_from_this 机制。

总结