关于shared_ptr的几点

//测试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
}