1. 介绍
shared_ptr 是通过指针保持某个对象的共享拥有权的智能指针。
若干个 shared_ptr 对象能够拥有同一个对象；最后一个指向该对象的 shared_ptr 被销毁或重置时。该对象被销毁。销毁该对象时使用的是 delete 表达式或者是在构造 shared_ptr 时传入的自己定义删除器（deleter）。
特点：
- shared_ptr 也能够不拥有对象。称作空（empty）。
- 最后一个shared_ptr指针被删除时，对象才被删除。
- shared_ptr 持有的指针是通过 get() 返回的；而控制块所持有的指针/对象则是终于引用计数归零时会被删除的那个。两者并不一定相等。
shared_ptr 的析构函数会将控制块中的 shared_ptr 计数器减一，假设减至零。控制块就会调用被管理对象的析构函数。
但控制块本身直到 std::weak_ptr 计数器相同归零时才会释放。
在std，std::tr1和boost中都含有这个智能指针。差别能够看以下这段话：
1 - std::bind is the the standard name for it. This will be the name you use for C++11 compliant libraries. List of all libraries in standardized C++.
2 - std::tr1::bind is C++ Technical Report 1 namespace. Between C++03 and C++11 there was the C++ Technical Report 1, which proposed additional libraries and enhancements. Most of these already existed in Boost at the time, and some of these library changes were adopted in the C++11 standard, like and (which contains std::bind). The std::tr1 namespace was used to differentiate the libraries in their work-in-progress state, as opposed to everything standardized in the std namespace.
3 - boost::bind is for bind in the boost namespace, if you are using the Boost library. Boost encompasses much more than what is in TR1 and what i in C++11’s std library. List of all libraries in Boost as of 1.52.0
Most of what was in TR1 has been standardized and is in the C++11 std namespace, and C++11 contains more libraries than mentioned in TR1 that were adapted from Boost constructs, like threading support defined in .
Part of what defines what you can use and which namespace you can use now depends on your compiler. I don’t recall, but I think the more recent GCC-g++ implementations have started using std namespaces for the new C++11 libraries, but might require a different compiler flag to activate that. They will still support the std::tr1 namespace though. Visual C++ 2010 moved what was previously in std::tr1 into the normal std namespace, but Visual C++ 2008 still used std::tr1.
2. shared_ptr使用
正确合理的使用shared_ptr智能指针能够防止内存泄露，以下通过一段代码就能够非常好地说明问题。
#include <stdio.h>
#include <iostream>
#include <tr1/memory>
#include <thread>
#include <chrono>
#include <mutex>
class A{
public:
A(){
std::cout<<"Construct A!"<<std::endl;
};
~A(){
std::cout<<"Destruct A!"<<std::endl;
};
};
class B: public A {
public:
B(){
std::cout<<"Construct B!"<<std::endl;
};
~B(){
std::cout<<"Destruct B!"<<std::endl;
};
};
int main(){
B *b1 = new B();
std::cout<<"-----------divid line--------"<<std::endl;
std::tr1::shared_ptr<B> b2(new B());
return 0;
}
A是基类，B继承于A。通过B *b1 = new B()定义一个B类的对象。观察其构造和析构过程。然后再通过shared_ptr定义B的对象，观察构造和析构过程。结果例如以下：
Construct A!
Construct B!
———–divid line——–
Construct A!
Construct B!
Destruct B!
Destruct A!
结果已经非常能说明问题了。！！
