一 什么是智能指针

c++的智能指针是利用了c++的RAII机制，这样可以及时的释放资源，且即使代码中触发了异常，也不会因为忘记写delete而没有释放内存。智能指针提供了一种同一资源管理的方式，就像是资源的proxy，智能指针内部维护了一个对资源的引用计数，每当被拷贝时就加一，被释放时减一。

二 正确的智能指针实例

class B;
class A {
public:
    A() {
        cout << "构造 A" << endl;
    }
    ~A() {
        cout << "析构 A" << endl;
    }
};

class B {
public:
    B() {
        cout << "构造 B" << endl;
    }
    ~B() {
        cout << "析构 B" << endl;
    }
};

void test() {
    shared_ptr<A> ap(new A()); 
    shared_ptr<B> bp(new B()); 
    cout << ap.use_count() << endl;
    cout << bp.use_count() << endl;
}

int main() {
    test();
    return 0;
}

结果：ap和bp的引用计数都为1。

三 异常情况：循环依赖

class B;
class A {
public:
    shared_ptr<B> spb;
    A() {
        cout << "构造 A" << endl;
    }
    ~A() {
        cout << "析构 A" << endl;
    }
};

class B {
public:
    shared_ptr<A> spa;
    B() {
        cout << "构造 B" << endl;
    }
    ~B() {
        cout << "析构 B" << endl;
    }
};

void test() {
    shared_ptr<A> ap(new A());
    shared_ptr<B> bp(new B());
    cout << ap.use_count() << endl;
    cout << bp.use_count() << endl;
    if (true) {
        ap -> spb = bp;
        bp -> spa = ap;
    }
    cout << ap.use_count() << endl;
    cout << bp.use_count() << endl;
}

int main() {
    test();
    return 0;
}

输出：
构造 A
构造 B
1
1
2
2

ap和bp两个智能指针中出现了循环依赖的情况，导致本应该在if(true)结束后就释放的资源，无法进行释放，引用计数本应降为1，实际还为2。
那么如何解决这种循环依赖问题呢，c++标准库提供了另外一种智能指针weak_ptr，weak_ptr 只能由shared_ptr或者其它的weak_ptr构造，weak_ptr和shared_ptr共享一个引用计数对象，shared_ptr被weak_ptr拷贝时，会在其引用计数对象上增加一个weak_count, 但不增加ref_count。ref_count减为0时销毁管理资源。

三 正确做法

class B;
class A {
public:
    weak_ptr<B> spb;
    A() {
        cout << "构造 A" << endl;
    }
    ~A() {
        cout << "析构 A" << endl;
    }
};

class B {
public:
    weak_ptr<A> spa;
    B() {
        cout << "构造 B" << endl;
    }
    ~B() {
        cout << "析构 B" << endl;
    }
};

void test() {
    shared_ptr<A> ap(new A());
    shared_ptr<B> bp(new B());
    cout << ap.use_count() << endl;
    cout << bp.use_count() << endl;
    if (true) {
        ap -> spb = bp;
        bp -> spa = ap;
    }
    cout << ap.use_count() << endl;
    cout << bp.use_count() << endl;
}

int main() {
    test();
    return 0;
}

输出：
构造 A
构造 B
1
1
1
1
析构 B
析构 A

引用计数减了。

智能指针的线程安全问题

根据c++的标准，shared_ptr提供了int和std::string等一个级别的线程安全级别。也就是说不能保证其线程安全，这里引用stackOverFlow上面的一个回答：

std::shared_ptr is not thread safe.
A shared pointer is a pair of two pointers, one to the object and one to a control block (holding the ref counter, links to weak pointers ...).
There can be multiple std::shared_ptr and whenever they access the control block to change the reference counter it's thread-safe but the std::shared_ptr itself is NOT thread-safe or atomic.
If you assign a new object to a std::shared_ptr while another thread uses it, it might end up with the new object pointer but still using a pointer to the control block of the old object => CRASH.

大意为一个shared_ptr有两个重要成员变量，ref_count和shared_ptr，ref_count本身是原子的，可以保证其线程安全，但是shared_ptr指针并不是线程安全的。所以如果将shared_ptr reset为一个新的智能指针，那么可能会出现新指针指向旧的控制块，导致崩溃。

还有智能指针指向元素的线程安全性由对象自己控制。