C++智能指针 shared_ptr
shared_ptr 是一个标准的共享所有权的智能指针, 允许多个指针指向同一个对象. 定义在 memory 文件中(非memory.h), 命名空间为 std.
shared_ptr 是为了解决 auto_ptr 在对象所有权上的局限性(auto_ptr 是独占的), 在使用引用计数的机制上提供了可以共享所有权的智能指针, 当然这需要额外的开销:
(1) shared_ptr 对象除了包括一个所拥有对象的指针外, 还必须包括一个引用计数代理对象的指针.
(2) 时间上的开销主要在初始化和拷贝操作上, *和->操作符重载的开销跟auto_ptr是一样.
(3) 开销并不是我们不使用shared_ptr的理由, 永远不要进行不成熟的优化, 直到性能分析器告诉你这一点.
使用方法:
可以使用模板函数 make_shared 创建对象, make_shared 需指定类型('<>'中)及参数('()'内), 传递的参数必须与指定的类型的构造函数匹配. 如:
std::shared_ptr<int> sp1 = std::make_shared<int>(10);
std::shared_ptr<std::string> sp2 = std::make_shared<std::string>("Hello c++");
也可以定义 auto 类型的变量来保存 make_shared 的结果.
auto sp3 = std::make_shared<int>(11);
printf("sp3=%d
", *sp3);
auto sp4 = std::make_shared<std::string>("C++11");
printf("sp4=%s
", (*sp4).c_str());
成员函数
use_count 返回引用计数的个数
unique 返回是否是独占所有权( use_count 为 1)
swap 交换两个 shared_ptr 对象(即交换所拥有的对象)
reset 放弃内部对象的所有权或拥有对象的变更, 会引起原有对象的引用计数的减少
get 返回内部对象(指针), 由于已经重载了()方法, 因此和直接使用对象是一样的.如 shared_ptr<int> sp(new int(1)); sp 与 sp.get()是等价的
以下代码演示各个函数的用法与特点:
std::shared_ptr<int> sp0(new int(2)); std::shared_ptr<int> sp1(new int(11)); std::shared_ptr<int> sp2 = sp1; printf("%d ", *sp0); // 2 printf("%d ", *sp1); // 11 printf("%d ", *sp2); // 11 sp1.swap(sp0); printf("%d ", *sp0); // 11 printf("%d ", *sp1); // 2 printf("%d ", *sp2); // 11 std::shared_ptr<int> sp3(new int(22)); std::shared_ptr<int> sp4 = sp3; printf("%d ", *sp3); // 22 printf("%d ", *sp4); // 22 sp3.reset(); printf("%d ", sp3.use_count()); // 0 printf("%d ", sp4.use_count()); // 1 printf("%d ", sp3); // 0 printf("%d ", sp4); // 指向所拥有对象的地址 std::shared_ptr<int> sp5(new int(22)); std::shared_ptr<int> sp6 = sp5; std::shared_ptr<int> sp7 = sp5; printf("%d ", *sp5); // 22 printf("%d ", *sp6); // 22 printf("%d ", *sp7); // 22 printf("%d ", sp5.use_count()); // 3 printf("%d ", sp6.use_count()); // 3 printf("%d ", sp7.use_count()); // 3 sp5.reset(new int(33)); printf("%d ", sp5.use_count()); // 1 printf("%d ", sp6.use_count()); // 2 printf("%d ", sp7.use_count()); // 2 printf("%d ", *sp5); // 33 printf("%d ", *sp6); // 22 printf("%d ", *sp7); // 22
shared_ptr 的赋值构造函数和拷贝构造函数:
auto r = std::make_shared<int>(); // r 的指向的对象只有一个引用, 其 use_count == 1
auto q = r; (或auto q(r);) // 给 r 赋值, 令其指向另一个地址, q 原来指向的对象的引用计数减1(如果为0, 释放内存), r指向的对象的引用计数加1, 此时 q 与 r 指向同一个对象, 并且其引用计数相同, 都为原来的值加1.
以下面的代码测试:
std::shared_ptr<int> sp1 = std::make_shared<int>(10); std::shared_ptr<int> sp2 = std::make_shared<int>(11); auto sp3 = sp2; 或 auto sp3(sp2); printf("sp1.use_count = %d ", sp1.use_count()); // 1 printf("sp2.use_count = %d ", sp2.use_count()); // 2 printf("sp3.use_count = %d ", sp3.use_count()); // 2 sp3 = sp1; printf("sp1.use_count = %d ", sp1.use_count()); // 2 printf("sp2.use_count = %d ", sp2.use_count()); // 1 printf("sp3.use_count = %d ", sp3.use_count()); // 2
何时需要使用 shared_ptr ?
(1) 程序不知道自己需要使用多少对象. 如使用窗口类, 使用 shared_ptr 为了让多个对象能共享相同的底层数据.
std::vector<std::string> v1; // 一个空的 vector // 在某个新的作用域中拷贝数据到 v1 中 { std::vector<std::string> v2; v2.push_back("a"); v2.push_back("b"); v2.push_back("c"); v1 = v2; } // 作用域结束时 v2 被销毁, 数据被拷贝到 v1 中
(2) 程序不知道所需对象的准确类型.
(3) 程序需要在多个对象间共享数据.
自定义释放器(函数)
自定义释放器(函数), 它能完成对 shared_ptr 中保存的指针进行释放操作, 还能处理 shared_ptr 的内部对象未完成的部分工作.
假设如下是一个连接管理类, 此类由于历史原因, 无法在析构函数中进行断开连接, 此时用自定义的释放器可以很好的完成此工作:
class CConnnect { void Disconnect() { PRINT_FUN(); } }; void Deleter(CConnnect* obj) { obj->Disconnect(); // 做其它释放或断开连接等工作 delete obj; // 删除对象指针 } std::shared_ptr<CConnnect> sps(new CConnnect, Deleter);
使用 shared_ptr 的注意事项
(1) shared_ptr 作为被保护的对象的成员时, 小心因循环引用造成无法释放资源.
假设 a 对象中含有一个 shared_ptr<CB> 指向 b 对象, b 对象中含有一个 shared_ptr<CA> 指向 a 对象, 并且 a, b 对象都是堆中分配的。
考虑对象 b 中的 m_spa 是我们能最后一个看到 a 对象的共享智能指针, 其 use_count 为2, 因为对象 b 中持有 a 的指针, 所以当 m_spa 说再见时, m_spa 只是把 a 对象的 use_count 改成1; 对象 a 同理; 然后就失去了 a,b 对象的联系.
解决此方法是使用 weak_ptr 替换 shared_ptr . 以下为错误用法, 导致相互引用, 最后无法释放对象
class CB; class CA; class CA { public: CA(){} ~CA(){PRINT_FUN();} void Register(const std::shared_ptr<CB>& sp) { m_sp = sp; } private: std::shared_ptr<CB> m_sp; }; class CB { public: CB(){}; ~CB(){PRINT_FUN();}; void Register(const std::shared_ptr<CA>& sp) { m_sp = sp; } private: std::shared_ptr<CA> m_sp; }; std::shared_ptr<CA> spa(new CA); std::shared_ptr<CB> spb(new CB); spb->Register(spa); spa->Register(spb); printf("%d ", spb.use_count()); // 2 printf("%d ", spa.use_count()); // 2
运行上述代码会发现 CA, CB 析构函数都不会打印. 因为他们都没有释放内存.
(2) 小心对象内部生成 shared_ptr
class Y : public std::enable_shared_from_this<Y> { public: std::shared_ptr<Y> GetSharePtr() { return shared_from_this(); } };
对普通的类(没有继承 enable_shared_from_this) T 的 shared_ptr<T> p(new T). p 作为栈对象占8个字节，为了记录( new T )对象的引用计数, p 会在堆上分配 16 个字节以保存引用计数等“智能信息”.
share_ptr 没有“嵌入(intrusive)”到T对象, 或者说T对象对 share_ptr 毫不知情.
而 Y 对象则不同, Y 对象已经被“嵌入”了一些 share_ptr 相关的信息, 目的是为了找到“全局性”的那16字节的本对象的“智能信息”.
考虑下面的代码: Y y; std::shared_ptr<Y> spy = y.GetSharePtr(); // 错误, y 根本不是 new 创建的 Y* y = new Y; std::shared_ptr<Y> spy = y->GetSharePtr(); // 错误, 问题依旧存在, 程序直接崩溃 正确用法: std::shared_ptr<Y> spy(new Y); std::shared_ptr<Y> p = spy->GetSharePtr(); printf("%d ", p.use_count()); // 2
(3) 小心多线程对引用计数的影响
首先, 如果是轻量级的锁, 比如 InterLockIncrement 等, 对程序影响不大; 如果是重量级的锁, 就要考虑因为 share_ptr 维护引用计数而造成的上下文切换开销.
其次, 多线程同时对 shared_ptr 读写时, 行为不确定, 因为shared_ptr本身有两个成员px，pi. 多线程同时对 px 读写要出问题, 与一个 int 的全局变量多线程读写会出问题的原因一样.
(4) 与 weak_ptr 一起工作时, weak_ptr 在使用前需要检查合法性
std::weak_ptr<A> wp; { std::shared_ptr<A> sp(new A); //sp.use_count()==1 wp = sp; //wp不会改变引用计数，所以sp.use_count()==1 std::shared_ptr<A> sp2 = wp.lock(); //wp没有重载->操作符。只能这样取所指向的对象 } printf("expired:%d ", wp.expired()); // 1 std::shared_ptr<A> sp_null = wp.lock(); //sp_null .use_count()==0;
上述代码中 sp 和 sp2 离开了作用域, 其容纳的对象已经被释放了. 得到了一个容纳 NULL 指针的 sp_null 对象.
在使用 wp 前需要调用 wp.expired() 函数判断一下. 因为 wp 还仍旧存在, 虽然引用计数等于0，仍有某处“全局”性的存储块保存着这个计数信息.
直到最后一个 weak_ptr 对象被析构, 这块“堆”存储块才能被回收, 否则 weak_ptr 无法知道自己所容纳的那个指针资源的当前状态.
(5) shared_ptr 不支持数组, 如果使用数组, 需要自定义删除器, 如下是一个利用 lambda 实现的删除器:
std::shared_ptr<int> sps(new int[10], [](int *p){delete[] p;});
对于数组元素的访问, 需使要使用 get 方法取得内部元素的地址后, 再加上偏移量取得.
for (size_t i = 0; i < 10; i++) { *((int*)sps.get() + i) = 10 - i; } for (size_t i = 0; i < 10; i++) { printf("%d -- %d ", i, *((int*)sps.get() + i)); }
VC中的源码实现
template<class _Ty> class _Ptr_base { // base class for shared_ptr and weak_ptr public: typedef _Ptr_base<_Ty> _Myt; typedef _Ty _Elem; typedef _Elem element_type; _Ptr_base() : _Ptr(0), _Rep(0) { // construct } _Ptr_base(_Myt&& _Right) : _Ptr(0), _Rep(0) { // construct _Ptr_base object that takes resource from _Right _Assign_rv(_STD forward<_Myt>(_Right)); } template<class _Ty2> _Ptr_base(_Ptr_base<_Ty2>&& _Right) : _Ptr(_Right._Ptr), _Rep(_Right._Rep) { // construct _Ptr_base object that takes resource from _Right _Right._Ptr = 0; _Right._Rep = 0; } _Myt& operator=(_Myt&& _Right) { // construct _Ptr_base object that takes resource from _Right _Assign_rv(_STD forward<_Myt>(_Right)); return (*this); } void _Assign_rv(_Myt&& _Right) { // assign by moving _Right if (this != &_Right) _Swap(_Right); } long use_count() const { // return use count return (_Rep ? _Rep->_Use_count() : 0); } void _Swap(_Ptr_base& _Right) { // swap pointers _STD swap(_Rep, _Right._Rep); _STD swap(_Ptr, _Right._Ptr); } template<class _Ty2> bool owner_before(const _Ptr_base<_Ty2>& _Right) const { // compare addresses of manager objects return (_Rep < _Right._Rep); } void *_Get_deleter(const _XSTD2 type_info& _Type) const { // return pointer to deleter object if its type is _Type return (_Rep ? _Rep->_Get_deleter(_Type) : 0); } _Ty *_Get() const { // return pointer to resource return (_Ptr); } bool _Expired() const { // test if expired return (!_Rep || _Rep->_Expired()); } void _Decref() { // decrement reference count if (_Rep != 0) _Rep->_Decref(); } void _Reset() { // release resource _Reset(0, 0); } template<class _Ty2> void _Reset(const _Ptr_base<_Ty2>& _Other) { // release resource and take ownership of _Other._Ptr _Reset(_Other._Ptr, _Other._Rep, false); } template<class _Ty2> void _Reset(const _Ptr_base<_Ty2>& _Other, bool _Throw) { // release resource and take ownership from weak_ptr _Other._Ptr _Reset(_Other._Ptr, _Other._Rep, _Throw); } template<class _Ty2> void _Reset(const _Ptr_base<_Ty2>& _Other, const _Static_tag&) { // release resource and take ownership of _Other._Ptr _Reset(static_cast<_Elem *>(_Other._Ptr), _Other._Rep); } template<class _Ty2> void _Reset(const _Ptr_base<_Ty2>& _Other, const _Const_tag&) { // release resource and take ownership of _Other._Ptr _Reset(const_cast<_Elem *>(_Other._Ptr), _Other._Rep); } template<class _Ty2> void _Reset(const _Ptr_base<_Ty2>& _Other, const _Dynamic_tag&) { // release resource and take ownership of _Other._Ptr _Elem *_Ptr = dynamic_cast<_Elem *>(_Other._Ptr); if (_Ptr) _Reset(_Ptr, _Other._Rep); else _Reset(); } template<class _Ty2> void _Reset(auto_ptr<_Ty2>& _Other) { // release resource and take _Other.get() _Ty2 *_Px = _Other.get(); _Reset0(_Px, new _Ref_count<_Elem>(_Px)); _Other.release(); _Enable_shared(_Px, _Rep); } #if _HAS_CPP0X template<class _Ty2> void _Reset(_Ty *_Ptr, const _Ptr_base<_Ty2>& _Other) { // release resource and alias _Ptr with _Other_rep _Reset(_Ptr, _Other._Rep); } #endif /* _HAS_CPP0X */ void _Reset(_Ty *_Other_ptr, _Ref_count_base *_Other_rep) { // release resource and take _Other_ptr through _Other_rep if (_Other_rep) _Other_rep->_Incref(); _Reset0(_Other_ptr, _Other_rep); } void _Reset(_Ty *_Other_ptr, _Ref_count_base *_Other_rep, bool _Throw) { // take _Other_ptr through _Other_rep from weak_ptr if not expired // otherwise, leave in default state if !_Throw, // otherwise throw exception if (_Other_rep && _Other_rep->_Incref_nz()) _Reset0(_Other_ptr, _Other_rep); else if (_Throw) _THROW_NCEE(bad_weak_ptr, 0); } void _Reset0(_Ty *_Other_ptr, _Ref_count_base *_Other_rep) { // release resource and take new resource if (_Rep != 0) _Rep->_Decref(); _Rep = _Other_rep; _Ptr = _Other_ptr; } void _Decwref() { // decrement weak reference count if (_Rep != 0) _Rep->_Decwref(); } void _Resetw() { // release weak reference to resource _Resetw((_Elem *)0, 0); } template<class _Ty2> void _Resetw(const _Ptr_base<_Ty2>& _Other) { // release weak reference to resource and take _Other._Ptr _Resetw(_Other._Ptr, _Other._Rep); } template<class _Ty2> void _Resetw(const _Ty2 *_Other_ptr, _Ref_count_base *_Other_rep) { // point to _Other_ptr through _Other_rep _Resetw(const_cast<_Ty2*>(_Other_ptr), _Other_rep); } template<class _Ty2> void _Resetw(_Ty2 *_Other_ptr, _Ref_count_base *_Other_rep) { // point to _Other_ptr through _Other_rep if (_Other_rep) _Other_rep->_Incwref(); if (_Rep != 0) _Rep->_Decwref(); _Rep = _Other_rep; _Ptr = _Other_ptr; } private: _Ty *_Ptr; _Ref_count_base *_Rep; template<class _Ty0> friend class _Ptr_base; }; template<class _Ty> class shared_ptr : public _Ptr_base<_Ty> { // class for reference counted resource management public: typedef shared_ptr<_Ty> _Myt; typedef _Ptr_base<_Ty> _Mybase; shared_ptr() { // construct empty shared_ptr object } template<class _Ux> explicit shared_ptr(_Ux *_Px) { // construct shared_ptr object that owns _Px _Resetp(_Px); } template<class _Ux, class _Dx> shared_ptr(_Ux *_Px, _Dx _Dt) { // construct with _Px, deleter _Resetp(_Px, _Dt); } //#if _HAS_CPP0X #if defined(_NATIVE_NULLPTR_SUPPORTED) && !defined(_DO_NOT_USE_NULLPTR_IN_STL) shared_ptr(_STD nullptr_t) { // construct with nullptr _Resetp((_Ty *)0); } template<class _Dx> shared_ptr(_STD nullptr_t, _Dx _Dt) { // construct with nullptr, deleter _Resetp((_Ty *)0, _Dt); } template<class _Dx, class _Alloc> shared_ptr(_STD nullptr_t, _Dx _Dt, _Alloc _Ax) { // construct with nullptr, deleter, allocator _Resetp((_Ty *)0, _Dt, _Ax); } #endif /* defined(_NATIVE_NULLPTR_SUPPORTED) etc. */ template<class _Ux, class _Dx, class _Alloc> shared_ptr(_Ux *_Px, _Dx _Dt, _Alloc _Ax) { // construct with _Px, deleter, allocator _Resetp(_Px, _Dt, _Ax); } //#endif /* _HAS_CPP0X */ #if _HAS_CPP0X template<class _Ty2> shared_ptr(const shared_ptr<_Ty2>& _Right, _Ty *_Px) { // construct shared_ptr object that aliases _Right this->_Reset(_Px, _Right); } #endif /* _HAS_CPP0X */ shared_ptr(const _Myt& _Other) { // construct shared_ptr object that owns same resource as _Other this->_Reset(_Other); } template<class _Ty2> shared_ptr(const shared_ptr<_Ty2>& _Other, typename enable_if<is_convertible<_Ty2 *, _Ty *>::value, void *>::type * = 0) { // construct shared_ptr object that owns same resource as _Other this->_Reset(_Other); } template<class _Ty2> explicit shared_ptr(const weak_ptr<_Ty2>& _Other, bool _Throw = true) { // construct shared_ptr object that owns resource *_Other this->_Reset(_Other, _Throw); } template<class _Ty2> shared_ptr(auto_ptr<_Ty2>& _Other) { // construct shared_ptr object that owns *_Other.get() this->_Reset(_Other); } template<class _Ty2> shared_ptr(const shared_ptr<_Ty2>& _Other, const _Static_tag& _Tag) { // construct shared_ptr object for static_pointer_cast this->_Reset(_Other, _Tag); } template<class _Ty2> shared_ptr(const shared_ptr<_Ty2>& _Other, const _Const_tag& _Tag) { // construct shared_ptr object for const_pointer_cast this->_Reset(_Other, _Tag); } template<class _Ty2> shared_ptr(const shared_ptr<_Ty2>& _Other, const _Dynamic_tag& _Tag) { // construct shared_ptr object for dynamic_pointer_cast this->_Reset(_Other, _Tag); } shared_ptr(_Myt&& _Right) : _Mybase(_STD forward<_Myt>(_Right)) { // construct shared_ptr object that takes resource from _Right } template<class _Ty2> shared_ptr(shared_ptr<_Ty2>&& _Right, typename enable_if<is_convertible<_Ty2 *, _Ty *>::value, void *>::type * = 0) : _Mybase(_STD forward<shared_ptr<_Ty2> >(_Right)) { // construct shared_ptr object that takes resource from _Right } #if _HAS_CPP0X template<class _Ux, class _Dx> shared_ptr(_STD unique_ptr<_Ux, _Dx>&& _Right) { // construct from unique_ptr _Resetp(_Right.release(), _Right.get_deleter()); } template<class _Ux, class _Dx> _Myt& operator=(unique_ptr<_Ux, _Dx>&& _Right) { // move from unique_ptr shared_ptr(_STD move(_Right)).swap(*this); return (*this); } #endif /* _HAS_CPP0X */ _Myt& operator=(_Myt&& _Right) { // construct shared_ptr object that takes resource from _Right shared_ptr(_STD move(_Right)).swap(*this); return (*this); } template<class _Ty2> _Myt& operator=(shared_ptr<_Ty2>&& _Right) { // construct shared_ptr object that takes resource from _Right shared_ptr(_STD move(_Right)).swap(*this); return (*this); } void swap(_Myt&& _Right) { // exchange contents with movable _Right _Mybase::swap(_STD move(_Right)); } ~shared_ptr() { // release resource this->_Decref(); } _Myt& operator=(const _Myt& _Right) { // assign shared ownership of resource owned by _Right shared_ptr(_Right).swap(*this); return (*this); } template<class _Ty2> _Myt& operator=(const shared_ptr<_Ty2>& _Right) { // assign shared ownership of resource owned by _Right shared_ptr(_Right).swap(*this); return (*this); } template<class _Ty2> _Myt& operator=(auto_ptr<_Ty2>& _Right) { // assign ownership of resource pointed to by _Right shared_ptr(_Right).swap(*this); return (*this); } void reset() { // release resource and convert to empty shared_ptr object shared_ptr().swap(*this); } template<class _Ux> void reset(_Ux *_Px) { // release, take ownership of _Px shared_ptr(_Px).swap(*this); } template<class _Ux, class _Dx> void reset(_Ux *_Px, _Dx _Dt) { // release, take ownership of _Px, with deleter _Dt shared_ptr(_Px, _Dt).swap(*this); } //#if _HAS_CPP0X template<class _Ux, class _Dx, class _Alloc> void reset(_Ux *_Px, _Dx _Dt, _Alloc _Ax) { // release, take ownership of _Px, with deleter _Dt, allocator _Ax shared_ptr(_Px, _Dt, _Ax).swap(*this); } //#endif /* _HAS_CPP0X */ void swap(_Myt& _Other) { // swap pointers this->_Swap(_Other); } _Ty *get() const { // return pointer to resource return (this->_Get()); } typename tr1::add_reference<_Ty>::type operator*() const { // return reference to resource return (*this->_Get()); } _Ty *operator->() const { // return pointer to resource return (this->_Get()); } bool unique() const { // return true if no other shared_ptr object owns this resource return (this->use_count() == 1); } _OPERATOR_BOOL() const { // test if shared_ptr object owns no resource return (this->_Get() != 0 ? _CONVERTIBLE_TO_TRUE : 0); } private: template<class _Ux> void _Resetp(_Ux *_Px) { // release, take ownership of _Px _TRY_BEGIN // allocate control block and reset _Resetp0(_Px, new _Ref_count<_Ux>(_Px)); _CATCH_ALL // allocation failed, delete resource delete _Px; _RERAISE; _CATCH_END } template<class _Ux, class _Dx> void _Resetp(_Ux *_Px, _Dx _Dt) { // release, take ownership of _Px, deleter _Dt _TRY_BEGIN // allocate control block and reset _Resetp0(_Px, new _Ref_count_del<_Ux, _Dx>(_Px, _Dt)); _CATCH_ALL // allocation failed, delete resource _Dt(_Px); _RERAISE; _CATCH_END } //#if _HAS_CPP0X template<class _Ux, class _Dx, class _Alloc> void _Resetp(_Ux *_Px, _Dx _Dt, _Alloc _Ax) { // release, take ownership of _Px, deleter _Dt, allocator _Ax typedef _Ref_count_del_alloc<_Ux, _Dx, _Alloc> _Refd; typename _Alloc::template rebind<_Refd>::other _Al = _Ax; _TRY_BEGIN // allocate control block and reset _Refd *_Ptr = _Al.allocate(1); new (_Ptr) _Refd(_Px, _Dt, _Al); _Resetp0(_Px, _Ptr); _CATCH_ALL // allocation failed, delete resource _Dt(_Px); _RERAISE; _CATCH_END } //#endif /* _HAS_CPP0X */ public: template<class _Ux> void _Resetp0(_Ux *_Px, _Ref_count_base *_Rx) { // release resource and take ownership of _Px this->_Reset0(_Px, _Rx); _Enable_shared(_Px, _Rx); } };