shared_ptr是一种智能指针,他的作用如同指针,但会记录有多少shared_ptr指向同一个对象。使用时必须引用头文件<boost/shared_ptr.hpp>
template<class T>
class ShartedPtr
{
public:
//构造函数
ShartedPtr(T* ptr)
:_ptr(ptr)
, _pCount(new int(1))
{
}
//拷贝构造
ShartedPtr(const ShartedPtr<T>&sp)
:_ptr(sp._ptr)
, _pCount(sp._pCount)
{
++(*_pCount);
}
//赋值
ShartedPtr&operator = (ShartedPtr<T>sp)
{
swap(_ptr, sp._ptr);
swap(_pCount, sp._pCount);
return *this;
}
//重载*
T &operator*()
{
return *_ptr;
}
//重载->
T *operator->()
{
return _ptr;
}
//析构函数
~ShartedPtr()
{
Relase();
}
protected:
void Relase()
{
if (--(*_pCount) == 0)
{
delete _ptr;
delete _pCount;
}
}
private:
T* _ptr;
int *_pCount;
};
struct A
{
int _A;
};
int main()
{
ShartedPtr<int> sp1(new int(1));
ShartedPtr<int> sp2(sp1);
sp1 = sp2;
ShartedPtr<int> sp3(sp2);
*sp3 = 10;
ShartedPtr<A>sp4(new A);
sp4->_A = 30;
return 0;
}
引用计数存在线程安全问题
会出现循环引用问题
定制删除器
循环引用即在使用双向链表时,若使用shared_ptr则会出现在析构时由于同一块空间有两个对象指向,且对象两两之间相互指向,故在析构时两对象都在等对方的_pCount减为一,从而一直到最后对象都没有析构
shared_ptr<Node>cur(new Node(1));
shared_ptr<Node>next(new Node(1));
cur->_next=next;
next->_prev=cur;
shared_ptr的定制删除器
template<class T,class D>
class ShartedPtr
{
public:
//构造函数
ShartedPtr(T* ptr)
:_ptr(ptr)
, _pCount(new int(1))
{
}
//构造函数的一个重载
ShartedPtr(T* ptr,D del)
:_ptr(ptr)
, _pCount(new int(1))
, _del(del)
{
}
//拷贝构造
ShartedPtr(const ShartedPtr<T,D>&sp)
:_ptr(sp._ptr)
, _pCount(sp._pCount)
{
++(*_pCount);
}
//赋值
ShartedPtr&operator = (ShartedPtr<T,D>sp)
{
swap(_ptr, sp._ptr);
swap(_pCount, sp._pCount);
return *this;
}
//重载*
T &operator*()
{
return *_ptr;
}
//重载->
T *operator->()
{
return _ptr;
}
//析构函数
~ShartedPtr()
{
Release();
}
protected:
void Release()
{
if (--(*_pCount) == 0)
{
_del( _ptr);
delete _pCount;
}
}
private:
T* _ptr;
int *_pCount;
D _del;
};
struct DefaultDel
{
void operator()(void* ptr)
{
delete ptr;
}
};
struct Free
{
void operator()(void* ptr)
{
free(ptr);
}
};
//struct Fclose
//{
// void operator()(void* ptr)
// {
// fclose(FILE*(ptr));
// }
//};
int main()
{
ShartedPtr<int, DefaultDel>sp1(new int(1));
ShartedPtr<int, Free>sp2((int*)malloc(sizeof(int)));
}
ps:仿函数的介绍
仿函数就是使一个类使用看上去像一个函数,其实现就是类中实现一个operator().这个类就有了类似函数的行为。
struct Free
{
void operator()(void *ptr)
{
free( ptr);
}
};
void Testsharedptr()
{
int *p1=(int*)malloc(sizeof(int)*10);
shared_ptr<int>sp1(p1,Free());//在使用完后自动释放p1
}
转载于:https://blog.51cto.com/10797127/1760220