C++智能指针shared_ptr
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\n", *sp3);
auto sp4 = std::make_shared<std::string>("C++11");
printf("sp4=%s\n", (*sp4).c_str());
成员函数
u_count 返回引⽤计数的个数
unique 返回是否是独占所有权( u_count 为 1)
swap 交换两个 shared_ptr 对象(即交换所拥有的对象)
ret 放弃内部对象的所有权或拥有对象的变更, 会引起原有对象的引⽤计数的减少
薛仁贵有几个妻子
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\n", *sp0); // 2
printf("%d\n", *sp1); // 11
printf("%d\n", *sp2); // 11
sp1.swap(sp0);
printf("%d\n", *sp0); // 11
printf("%d\n", *sp1); // 2
printf("%d\n", *sp2); // 11
std::shared_ptr<int> sp3(new int(22));
std::shared_ptr<int> sp4 = sp3;
printf("%d\n", *sp3); // 22
printf("%d\n", *sp4); // 22
<();
printf("%d\n", sp3.u_count()); // 0
printf("%d\n", sp4.u_count()); // 1
printf("%d\n", sp3); // 0
printf("%d\n", sp4); // 指向所拥有对象的地址
std::shared_ptr<int> sp5(new int(22));
std::shared_ptr<int> sp6 = sp5;
std::shared_ptr<int> sp7 = sp5;
printf("%d\n", *sp5); // 22
printf("%d\n", *sp6); // 22
printf("%d\n", *sp7); // 22
printf("%d\n", sp5.u_count()); // 3
printf("%d\n", sp6.u_count()); // 3
printf("%d\n", sp7.u_count()); // 3
<(new int(33));
printf("%d\n", sp5.u_count()); // 1
printf("%d\n", sp6.u_count()); // 2
printf("%d\n", sp7.u_count()); // 2
printf("%d\n", *sp5); // 33
printf("%d\n", *sp6); // 22
printf("%d\n", *sp7); // 22
shared_ptr 的赋值构造函数和拷贝构造函数:
auto r = std::make_shared<int>(); // r 的指向的对象只有⼀个引⽤, 其 u_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.u_count = %d\n", sp1.u_count()); // 1
printf("sp2.u_count = %d\n", sp2.u_count()); // 2
printf("sp3.u_count = %d\n", sp3.u_count()); // 2
sp3 = sp1;
printf("sp1.u_count = %d\n", sp1.u_count()); // 2
printf("sp2.u_count = %d\n", sp2.u_count()); // 1
实现自我价值printf("sp3.u_count = %d\n", sp3.u_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; // 删除对象指针
}
2018数学三
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 对象的共享智能指针, 其 u_count 为2, 因为对象 b 中持有 a 的指针, 所以当m_spa 说再见时, m_spa 只是把 a 对象的 u_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\n", spb.u_count()); // 2
printf("%d\n", spa.u_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\n", p.u_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.u_count()==1
wp = sp; //wp不会改变引⽤计数，所以sp.u_count()==1
std::shared_ptr<A> sp2 = wp.lock(); //wp没有重载->操作符。只能这样取所指向的对象
}
printf("expired:%d\n", wp.expired()); // 1
std::shared_ptr<A> sp_null = wp.lock(); //sp_null .u_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*)() + i) = 10 - i;
}
for (size_t i = 0; i < 10; i++)
{
printf("%d -- %d\n", i, *((int*)() + i));
}
VC中的源码实现
template<class _Ty>
class _Ptr_ba
{ // ba class for shared_ptr and weak_ptr
public:
typedef _Ptr_ba<_Ty> _Myt;
typedef _Ty _Elem;
typedef _Elem element_type;
_Ptr_ba()
: _Ptr(0), _Rep(0)
{ // construct
}
_Ptr_ba(_Myt&& _Right)
: _Ptr(0), _Rep(0)
{ // construct _Ptr_ba object that takes resource from _Right
_Assign_rv(_STD forward<_Myt>(_Right));
}
template<class _Ty2>
_Ptr_ba(_Ptr_ba<_Ty2>&& _Right)
: _Ptr(_Right._Ptr), _Rep(_Right._Rep)
{ // construct _Ptr_ba object that takes resource from _Right
_Right._Ptr = 0;
_Right._Rep = 0;
}
_Myt& operator=(_Myt&& _Right)
{ // construct _Ptr_ba 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 u_count() const
{ // return u count
return (_Rep ? _Rep->_U_count() : 0);
}
void _Swap(_Ptr_ba& _Right)
{ // swap pointers
_STD swap(_Rep, _Right._Rep);
_STD swap(_Ptr, _Right._Ptr);
}
template<class _Ty2>
bool owner_before(const _Ptr_ba<_Ty2>& _Right) const
{ // compare address 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 _Ret()
{ // relea resource
_Ret(0, 0);
}
template<class _Ty2>
void _Ret(const _Ptr_ba<_Ty2>& _Other)
{ // relea resource and take ownership of _Other._Ptr
_Ret(_Other._Ptr, _Other._Rep, fal);
}
template<class _Ty2>
void _Ret(const _Ptr_ba<_Ty2>& _Other, bool _Throw)
{ // relea resource and take ownership from weak_ptr _Other._Ptr
_Ret(_Other._Ptr, _Other._Rep, _Throw);
}
template<class _Ty2>
void _Ret(const _Ptr_ba<_Ty2>& _Other, const _Static_tag&)
{ // relea resource and take ownership of _Other._Ptr
_Ret(static_cast<_Elem *>(_Other._Ptr), _Other._Rep);
克娄巴特拉
}
template<class _Ty2>
void _Ret(const _Ptr_ba<_Ty2>& _Other, const _Const_tag&)
{ // relea resource and take ownership of _Other._Ptr
_Ret(const_cast<_Elem *>(_Other._Ptr), _Other._Rep);
}
template<class _Ty2>
void _Ret(const _Ptr_ba<_Ty2>& _Other, const _Dynamic_tag&)
{ // relea resource and take ownership of _Other._Ptr
_Elem *_Ptr = dynamic_cast<_Elem *>(_Other._Ptr);
if (_Ptr)
_Ret(_Ptr, _Other._Rep);
el
_Ret();
}
template<class _Ty2>
void _Ret(auto_ptr<_Ty2>& _Other)
{ // relea resource and take _()删除重复行
_Ty2 *_Px = _();
_Ret0(_Px, new _Ref_count<_Elem>(_Px));
_lea();
_Enable_shared(_Px, _Rep);
}
#if _HAS_CPP0X
template<class _Ty2>
void _Ret(_Ty *_Ptr, const _Ptr_ba<_Ty2>& _Other)
{ // relea resource and alias _Ptr with _Other_rep
_Ret(_Ptr, _Other._Rep);
}
#endif /* _HAS_CPP0X */
void _Ret(_Ty *_Other_ptr, _Ref_count_ba *_Other_rep)
{ // relea resource and take _Other_ptr through _Other_rep if (_Other_rep)
_Other_rep->_Incref();
_Ret0(_Other_ptr, _Other_rep);
}
void _Ret(_Ty *_Other_ptr, _Ref_count_ba *_Other_rep, bool _Throw) { // take _Other_ptr through _Other_rep from weak_ptr if not expired
// otherwi, leave in default state if !_Throw,
