template<typename T>
class CSmartPtr
{
public:
CSmartPtr(T* ptr = nullptr)
:mptr(ptr)
{}
CSmartPtr(const CSmartPtr<T>& src)
{
mptr = new T(*src.mptr);
}
~CSmartPtr()
{
delete mptr;
mptr = nullptr;
}
T& operator*()
{
return *mptr;
}
T* operator->()
{
return mptr;
}
private:
T* mptr;
};
int main
{
}
不带引用计数:
auto_ptr机制:
ptr2拷贝构造之后,ptr1内的指针就为nullptr了!ptr2内的指针指向原来申请的内存!不推荐使用auto_ptr!
(C++11)scoped_ptr:(内部机制:)使用的很少:
推荐使用:unique_ptr:
内部也是和谐了这两个函数!但是提供了:
这么操作就明显看得出来,p1资源被转移到了p2,不像auto_ptr看不出来,容易出错!
带引用计数的智能指针:
shared_ptr、weak_ptr
带引用计数:给每一个对象资源,匹配一个引用计数
智能指针引用资源的时候,引用计数+1
智能指针不适用资源的时候,引用计数-1;
引用计数!=0的话,资源不释放,=0就释放!
//对资源进行引用计数的类
template<typename T>
class RefCnt
{
public:
RefCnt(T* ptr = nullptr)
mptr(ptr)
{
if(mptr!= nullptr)
mcount=1;
}
void addRef()
{
mcount++;
}
int delRef()
{
return --mcount;
}
private:
T* mptr;
int mcount;
};
template<typename T>
class CSmartPtr
{
public:
CSmartPtr(T* ptr = nullptr)
:mptr(ptr)
{
mpRefCnt = new RefCnt<T>(mptr);
}
CSmartPtr(const CSmartPtr<T>& src)
mptr(src.mptr),mpRefCnt(src.mpRefCnt)
{
if(mptr!=nullptr)
mpRefCnt->addRef();
}
CSmartPtr<T>& operator=(const CSmartPtr<T>& src)
{
if(this == &src)
return *this;
if(0 == mpRefCnt->delRef())
{
delete mptr;
}
mptr = src.mptr;
mpRefCnt = src.mpRefCnt;
mpRefCnt->addRef();
return *this;
}
~CSmartPtr()
{
if(0 == mpRefCnt->delRef())
{
delete mptr;
mptr = nullptr;
}
}
T& operator*()
{
return *mptr;
}
T* operator->()
{
return mptr;
}
private:
T* mptr;
RefCnt<T>* mpRefCnt;
};
shared_ptr和weak_ptr的mcount是线程安全的!