//测试shared_ptr的初始化
{
shared_ptr<int> p1(new int(3));
shared_ptr<int> p2 = make_shared<int>(3);//优先使用
if (*p1 == *p2)
cout << "equal" << endl;
shared_ptr<int> p3;
p3.reset(new int(3));
cout << *p3 << endl;
//不要用同一个指针初始化两个share_ptr
int *p = new int(30);
shared_ptr<int> pa(p);
shared_ptr<int> pb(p);//local error
long count = pa.use_count();
cout << "p被引用了 " << count << "次"<< endl;
}
//不要在函数参数中创建shared_ptr
void Test(shared_ptr<int> ptr, double t)
{
}
{
Test(shared_ptr<int>(new int), g());//warning
//正确写法
shared_ptr<int> ptrVar(new int);
Test(ptrVar, g());
}
在函数参数中创建指针会有问题:编译器对于函数参数的计算顺序是不可控的,可能先new int,然后调用
g(),最后生成shared_ptr。如果是这样子,当g()函数调用发生异常,而且此时shared_ptr还没有生成,
会导致内存泄漏。
//不要将this指针从shared_ptr直接返回出来
struct A
{
shared_ptr<A> GetSelf()
{
return shared_ptr<A>(this);
}
};
//这样子会导致A被析构两次,出现delete空悬指针错误
shared_ptr<A> p1(new A);
shared_ptr<A> p2 = p1->GetSelf();
正确做法:
struct A : public enable_shared_from_this<A>
{
shared_ptr<A> GetSelf()
{
//return shared_ptr<A>(this);
return shared_from_this();
}
};
//调用GetSelf时就不会出现析构两次了
shared_ptr<A> p1(new A);
shared_ptr<A> p2 = p1->GetSelf();
避免出现循环引用
struct B;
struct A
{
shared_ptr<B> bptr;
~A(){}
};
struct B
{
shared_ptr<A> aptr;
~B(){}
};
shared_ptr<A> pa(new A);
shared_ptr<B> pb(new B);
pa->bptr = pb;//导致use_count+1
pb->aptr = pa;//导致use_count+1
//结果会导致两个指针都不会析构,出现内存泄漏
如果要有对方的指针,建议使用weak_ptr
当用shared_ptr管理内置类型的数组时(不建议保存类数组),需要人为指定删除器
shared_ptr<int> intPtr(new int[10], [](int *p){delete []p;});
//或者
shared_ptr<int> intPtr1(new int[10], default_delete<int[]>());
shared_ptr有时候使用时,会意外的延长对象的生命期
class Foo
{
public:
void doit()
{
cout << __FUNCTION__ << endl;
}
};
shared_ptr<Foo> fooPtr(new Foo);
//对象func持有一份shared_ptr<Foo>的拷贝
std::function<void()> func = std::bind(&Foo::doit, fooPtr);
long count = fooPtr.use_count();
cout << "fooPtr use_count = " << count << endl;
运行
这里需要注意,和stl里面的容器一起使用时也会出现这种情况,需要注意
shared_ptr的使用:
class Foo
{
public:
Foo() { cout << "Foo()" << endl; }
~Foo() { cout << "~Foo()" << endl; }
};
int main()
{
shared_ptr<void> vptr = shared_ptr<Foo>(new Foo);
return 0;
}
输出:
Foo()
~Foo()
delete 单独转换的void*的指针时,会出问题。但是shared_ptr就不会。原理是啥?
下面是libcxx中shared_ptr的部分源码:
/** C1. shared_ptr 构造函数 **/
template<class _Tp>
template<class _Yp>
shared_ptr<_Tp>::shared_ptr(_Yp* __p,
typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type)
: __ptr_(__p)
{
unique_ptr<_Yp> __hold(__p);
typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, _AllocT > _CntrlBlk;
__cntrl_ = new _CntrlBlk(__p, default_delete<_Yp>(), _AllocT());
__hold.release();
__enable_weak_this(__p, __p);
}
/** C2. shared_ptr 拷贝构造 **/
template<class _Tp>
inline
shared_ptr<_Tp>::shared_ptr(const shared_ptr& __r) _NOEXCEPT
: __ptr_(__r.__ptr_),
__cntrl_(__r.__cntrl_)
{
if (__cntrl_)
__cntrl_->__add_shared();
}
/** C3. shared_ptr::__cntrl_ 类型 **/
__shared_weak_count* __cntrl_;
/** C4. shared_ptr 析构函数 **/
template<class _Tp>
shared_ptr<_Tp>::~shared_ptr()
{
if (__cntrl_)
__cntrl_->__release_shared();
}
/** C5. __shared_weak_count::__release_shared **/
bool __release_shared() _NOEXCEPT {
if (__libcpp_atomic_refcount_decrement(__shared_owners_) == -1) {
__on_zero_shared();
return true;
}
return false;
}
/** C6. __shared_ptr_pointer::__release_shared **/
template <class _Tp, class _Dp, class _Alloc>
/* 重点 !!! virtual !!! */
void
__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared() _NOEXCEPT
{
// __data__ 是 内部工具类__compressed_pair
// __data_.first().second()是 deleter
// __data_.first().first() 是 shared_ptr<T> 中T类型的指针
__data_.first().second()(__data_.first().first());
__data_.first().second().~_Dp();
}
/** C7. default deleter **/
template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS default_delete {
// ... 此处省略若干行
void operator()(_Tp* __ptr) const _NOEXCEPT {
delete __ptr;
}
};
- 每一个shared_ptr 内部有一个control block,里面会存放一个要维护的指针,一个计数,一个删除器(deleter),一个分配(allocator)。
- 这里我们要关心的是删除器。顾名思义,它是用来删除指针的。
- shared_ptr中的 有一个__cntrl_即control block。字段的类型是__shared_weak_count指针,这个类是一个非模板类。
--shared_ptr<T>创建的control block的类型是一个类模板
- template <class _Tp, class _Dp, class _Alloc> __shared_ptr_pointer继承自__shared_weak_count。 见代码C3。
- 当创建一个新的shared_ptr的时候,构建一个新的control block。见代码C1。
- 当一个shared_ptr A赋值或者拷贝构造给另一个shared_ptrB的时候(当然是在类型能够转换的前提下),
- B会把A的__cntrl_拷一份,同时将其引用加一。注意,这个时候拷贝的是指针,__cntrl_还是指向最初创建的那个对象。见代码C2。
- 当shared_ptr被析构或者重置的时候会调用__cntrl_->__release_shared()。见代码C4。
- __cntrl_->__release_shared()如果发现当前的计数为-1的时候,调用__on_zero_shared()。见代码C5。
- __on_zero_shared是一个虚方法,那么它就会调用到最初创建的__shared_ptr_pointer的实现。
- __shared_ptr_pointer的实现中是有完整的类型和删除器的信息的。见代码C6。
- 默认的删除器很简单的执行了delete __ptr操作,因为类型是已知的所以能够正确的调用到析构函数。见代码C7。
使用shared_ptr可以避免好多内存问题,但是要注意shared_ptr使用的一些陷阱。注意shared_ptr和weak_ptr的搭配使用。还有一个smart pointer是unique_ptr,也要注意和shared_ptr使用的区别。
关于shared_ptr和weak_ptr联合使用的问题—关于对象池的应用
假定有一个stock类,代表股票的价格,每个stock对象有一个唯一的标识string,它能获取新价格
假定有一个stock的对象池
class StockFactory
{
public:
shared_ptr<Stock> get(const string& key);
private:
mutable MutexLock mutex_;
map<string, shared_ptr<Stock> > stocks_;
};
//get的逻辑很简单,找到就返回,找不到就新建
shared_ptr<Stock> StockFactory::get(const string& key)
{
MutexLockGuard lock(mutex_);
auto iter = stocks_.find(key);
if (iter == stocks_.end())
{
shared_ptr<Stock> stockPtr=make_shared<Stock>(key, 1000);
stocks_[key] = stockPtr;
}
return stockPtr;
}
get函数逻辑虽然简单,但是却有一个问题,这个stock对象永远不会销毁,map里面存放的是shared_ptr。
那么,将shared_ptr换成weak_ptr似乎是顺理成章的事情
shared_ptr<Stock> StockFactory::get(const string& key)
{
shared_ptr<Stock> pStock;
MutexLockGuard lock(mutex_);
weak_ptr<Stock>& wkStock = stocks_[key];
pStock = wkStock.lock();
if (!pStock)
{
pStock.reset(new Stock(key, 1000));
wkStock = pStock;
}
return pStock;
}
改为weak_ptr存放在map中,但是还有个问题,就是虽然外面的shared_ptr释放掉了,map里面的weak_ptr也不指向真实的shared_ptr了,但是weak_ptr也释放不掉啊,所以必须在shared_ptr析构掉的同时,也要删除掉map里面存放的weak_ptr
既然所有的stock对象都是从StockFactory里面get出来的,那么,我们在shared_ptr里面存放一个deleter应该就好解决了
所以,在get函数中,我们修改pStock的构造方式,给它添加一个删除器
pStock.reset(new Stock(key, 1000), std::bind(&StockFactory::deleteStock, this, _1));
...
private:
void deleteStock(Stock* stock)
{
if (stock)
{
MutexLockGuard lock(mutex_);
stocks_.erase(stock->key());
}
delete stock;
}
改到这一步,初看是没什么问题,但是,我们在传递删除器的时候,构造lambda式子传递了this指针,这也意味着当StockFactory对象析构时,调用删除器回core dump,ok,这个时候我们希望使用shared_ptr传递进去
首先,修改
class StockFactory : public std::enable_shared_from_this<StockFactory>
{...}
在get函数中修改pStock的创建方式
pStick.reset(new Stock(key,1000), std::bind(&StockFactory::deleteStock, shared_from_this(), _1));
这样子也有问题,StockFactory的生命期被意外的延长了,那么使用弱回调weak_ptr,当对象还活着的时候,我们使用weak_ptr进行提升,然后执行删除
完整的StockFactory代码:
class StockFactory : enable_shared_from_this<StockFActory>
{
public:
shared_ptr<Stock> get(const string& key)
{
shared_ptr<Stock> pStock;
MutexLockGuard lock(mutex_);
weak_ptr<Stock>& wkStock = stocks_[key];
pStock = wkStock.lock();
if (!pStock)
{
pStock.reset(new Stock(key, 1000),
std::bind(&StockFactory::weakDeleteCallback,
std::weak_ptr<StockFactory>(shared_from_this()),
_1));
wkStock = pStock;
}
return pStock;
}
private:
static void weakDeleteCallback(const std::weak_ptr<StockFactory>& wkFactory, Stock* stock)
{
shared_ptr<StockFActory> factory(wkFactory.lock());
if (factory)
factory->removeStock(stock);
delete stock;
}
void removeStock(Stock* stock)
{
if (stock != NULL)
{
MutexLockGuard lock(mutex_);
stocks_.erase(stock->key());
}
}
mutable MutexLock mutex_;
map<string, weak_ptr<Stock>> stocks_;
};
//测试1
void testLongLifeFactory()
{
shared_ptr<StockFActory> factory(new StockFActory);
{
shared_ptr<Stock> stock = factory->get("BIM");
shared_ptr<Stock> stock2 = factory->get("cad");
//stock destructs here
}
//factory destructs here
}
void testLongLifeStock()
{
shared_ptr<Stock> stock;
{
shared_ptr<StockFactory> factory(new StockFactory);
stock = factory->get("cad");
shared_ptr<Stock> stock2 = factory->get("cad");
//factory destructs here
}
//stock destructs here
}