C++侵入式智能指针的实现
简介
在现代C++编程中，智能指针给我们在资源管理上带来了很多好处，这里就不多说了。
在工作中，我们常常会用智能指针来管理资源，其中最常用的就是引用计数类智能指针了（shared_ptr）。
资源共享型的智能指针有两种实现，一种是侵入式，一种是非侵入式。
在教材里比较常见的是非侵入式的，它的实现完全放在智能指针模板里，模板类有一个用于保存资源类对象的指针变量，和一个用于记录资源对象使用计数的指针变量，这两个东西是所有的智能指针对象共享的，所以通过指针保存。
而侵入式则不同，它的实现分散在智能指针模板和使用智能指针模板的类中：模板类只有一个用于保存对象的指针变量，对象的计数放在了资源类中。
非侵入式智能指针，它的引用计数变量为了保证所有对象共享，需要用堆里的内存，所以需要用new，这个都一样，不一样的是使用new的次数。
侵入式智能指针的引用计数变量保存在对象里，因为对象是唯一的，所以引用计数也是唯一的。
相比非侵入式智能指针，它的好处是：
1、一个资源对象无论被多少个侵入式智能指针包含，从始至终只有一个引用计数变量，不需要在每一个使用智能指针对象的地方都new一个计数对象，这样子效率比较高，使用内存也比较少，也比较安全；
2、因为引用计数存储在对象本身，所以在函数调用的时候可以直接传递资源对象地址，而不用担心引用计数值丢失（非侵入式智能指针对象的拷贝，必须带着智能指针模板，否则就会出现对象引用计数丢失）。
缺点是：
1、资源类必须有引用计数变量，并且该变量的增减可以被侵入式智能指针模板基类操作，这显得麻烦；
2、如果该类并不想使用智能指针，它还是会带着引用计数变量。
另外，智能指针有一个无法避免的问题，就是循环引用。
侵入式智能指针实现
两个要点：
1.将引用计数变量从资源类中抽离出来，封装成一个基类，该基类包含了引用计数变量。如果一个类想使用智能指针，则只需要继承自该基类即可；
2.引用计数的基类，设计成模板类，接受引用计数类型作为参数，比如使用int类型或者原子计数类型作为引用计数变量。默认情况下应该使用原子计数类型作为引用计数变量。
3.引用计数基类的构造函数、拷贝构造函数、析构函数应为protected，即该类只能通过继承关系被使用。
4.拷贝构造函数并不拷贝引用计数基类的数据成员，而是重新将原子计数_atomic置为0——因为每个对象都有一个自己的引用计数，当发生对象拷贝构造时，新的对象的计数应该置为0，而不应该拷贝旧对象的计数。
5.赋值操作operator=，比如A=B，同上面一样，只对资源类的成员进行拷贝，而不拷贝其引用计数基类的数据成员。也就是说，将B的值赋给A，A的引用计数应该保持不变，而不能将B的引用计数拷贝过来——这是对象的拷贝，而不是智能指针的拷贝。
首先实现引用计数基类（注：Atomic的实现这里就不给出了）：
/
@brief智能指针基类.
所有需要智能指针支持的类都需要从该对象继承，
内部采用引用计数Atomic实现，对象可以放在容器中；
/
template
classHandleBaseT
{
public:
/原子计数类型/
typedefTatomic_type;
/
@brief复制。引用计数不能被复制。
@returnHandleBase&
/
HandleBaseT&operator=(constHandleBaseT&)
{
returnthis;
}
/
@brief增加计数
/
voidincRef(){_atomic.inc_fast();}
/
@brief减少计数,当计数==0时,且需要删除数据时,释放对象
/
voiddecRef()
{
if(_atomic.dec_and_test()&&!_bNoDelete)
{
_bNoDelete=true;
deletethis;
}
}
/
@brief获取计数.
@returnint计数值
/
intgetRef()const{return_atomic.get();}
/
@brief设置不自动释放.
@paramb是否自动删除,trueorfalse
/
voidsetNoDelete(boolb){_bNoDelete=b;}
protected:
/
@brief构造函数
/
HandleBaseT():_atomic(0),_bNoDelete(false)
{
}
/
@brief拷贝构造，_atomic和_bNoDelete不能被拷贝，只能重置
/
HandleBaseT(constHandleBaseT&):_atomic(0),_bNoDelete(false)
{
}
/
@brief析构
/
virtual~HandleBaseT()
{
}
protected:
/
计数
/
atomic_type_atomic;
/
是否自动删除
/
bool_bNoDelete;
};
//针对int类型计数变量的特化
//在类声明中定义的函数将自动inline，类外定义的函数需显式inline
template<>
inlinevoidHandleBaseT::incRef()
{
++_atomic;
}
template<>
inlinevoidHandleBaseT::decRef()
{
if(--_atomic==0&&!_bNoDelete)
{
_bNoDelete=true;
deletethis;
}
}
template<>
inlineintHandleBaseT::getRef()const
{
return_atomic;
}
//默认使用Atomic作为引用计数类型
typedefHandleBaseTHandleBase;
以上实现了计数基类，所有需要使用智能指针的对象必须继承自该类。
智能指针模板类的实现需要关注的几个点：
1.初始化、赋值等操作需要考虑参数是原始指针、其他类型的智能指针初、用同一类型的智能指针三种情况。
2.需要重载<、=、!=几个操作（非成员函数），左右操作数使用两个模板参数。
3.赋值操作需要检查自我赋值。
/
@brief空指针异常
/
structShared_PtrNull_Exception:publicException
{
Shared_PtrNull_Exception(conststring&buffer):Exception(buffer){};
~Shared_PtrNull_Exception()throw(){};
};
/
@brief智能指针模板类.
可以放在容器中,且线程安全的智能指针.
通过它定义智能指针，该智能指针通过引用计数实现，
可以放在容器中传递.
templateT必须继承于HandleBase
/
template
classShared_Ptr
{
public:
/
元素类型
/
typedefTelement_type;
/
@brief用原生指针初始化,计数+1.
@paramp
/
Shared_Ptr(Tp=0)
{
_ptr=p;
if(_ptr)
{
_ptr->incRef();
}
}
/
@brief用其他智能指针r的原生指针初始化,计数+1.
@paramY
@paramr
/
template
Shared_Ptr(constShared_Ptr&r)
{
_ptr=r._ptr;
if(_ptr)
{
_ptr->incRef();
}
}
/
@brief拷贝构造,计数+1.
@paramr
/
Shared_Ptr(constShared_Ptr&r)
{
_ptr=r._ptr;
if(_ptr)
{
_ptr->incRef();
}
}
/
@brief析构
/
~Shared_Ptr()
{
if(_ptr)
{
_ptr->decRef();
}
}
/
@brief赋值,普通指针.
@paramp
@returnShared_Ptr&
/
Shared_Ptr&operator=(Tp)
{
if(_ptr!=p)
{
if(p)
{
p->incRef();
}
Tptr=_ptr;
_ptr=p;
if(ptr)
{
ptr->decRef();
}
}
returnthis;
}
/
@brief赋值,其他类型智能指针.
@paramY
@paramr
@returnShared_Ptr&
/
template
Shared_Ptr&operator=(constShared_Ptr&r)
{
if(_ptr!=r._ptr)
{
if(r._ptr)
{
r._ptr->incRef();
}
Tptr=_ptr;
_ptr=r._ptr;
if(ptr)
{
ptr->decRef();
}
}
returnthis;
}
/
@brief赋值,该类型其他执政指针.
@paramr
@returnShared_Ptr&
/
Shared_Ptr&operator=(constShared_Ptr&r)
{
if(_ptr!=r._ptr)
{
if(r._ptr)
{
r._ptr->incRef();
}
Tptr=_ptr;
_ptr=r._ptr;
if(ptr)
{
ptr->decRef();
}
}
returnthis;
}
/
@brief将其他类型的智能指针换成当前类型的智能指针.
@paramY
@paramr
@returnShared_Ptr
/www.sm136.com
template
staticShared_PtrdynamicCast(constShared_Ptr&r)
{
returnShared_Ptr(dynamic_cast(r._ptr));
}
/
@brief将其他原生类型的指针转换成当前类型的智能指针.
@paramY
@paramp
@returnShared_Ptr
/
template
staticShared_PtrdynamicCast(Yp)
{
returnShared_Ptr(dynamic_cast(p));
}
/
@brief获取原生指针.
@returnT
/
Tget()const
{
return_ptr;
}
/
@brief调用.
@returnT
/
Toperator->()const
{
if(!_ptr)
{
throwNullHandleException();
}
return_ptr;
}
/
@brief引用.
@returnT&
/
T&operator()const
{
if(!_ptr)
{
throwNullHandleException();
}
return_ptr;
}
/
@brief是否有效.
@returnbool
/
operatorbool()const
{
return_ptr?true:false;
}
/
@brief交换指针.
@paramother
/
voidswap(Shared_Ptr&other)
{
std::swap(_ptr,other._ptr);
}
protected:
/
@brief抛出异常
/
voidthrowNullHandleException()const;
public:
T_ptr;
};
/
@brief抛出异常.
@paramT
@paramfile
@paramline
/
templateinlinevoid
Shared_Ptr::throwNullHandleException()const
{
throwShared_PtrNull_Exception("shared_ptrnullhandleerror");
}
/
@brief==判断.
@paramT
@paramU
@paramlhs
@paramrhs
@returnbool
/
template
inlinebooloperator==(constShared_Ptr&lhs,constShared_Ptr&rhs)
{
Tl=lhs.get();
Ur=rhs.get();
if(l&&r)
{
returnl==r;
}
else
{
return!l&&!r;
}
}
/
@brief不等于判断.
@paramT
@paramU
@paramlhs
@paramrhs
@returnbool
/
template
inlinebooloperator!=(constShared_Ptr&lhs,constShared_Ptr&rhs)
{
Tl=lhs.get();
Ur=rhs.get();
if(l&&r)
{
returnl!=r;
}
else
{
returnl||r;
}
}
/
@brief小于判断,用于放在map等容器中.
@paramT
@paramU
@paramlhs
@paramrhs
@returnbool
/
template
inlinebooloperator<(constShared_Ptr&lhs,constShared_Ptr&rhs)
{
Tl=lhs.get();
Ur=rhs.get();
if(l&&r)
{
returnl
}
else
{
return!l&&r;
}
}
使用示例
classTest:publicHandleBase
{
//...
};
Shared_PtrmyTestClass=newTest();
|
|
