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!

　　结果已经非常能说明问题了。！！