shared_ptr 类

将引用计数智能指针围绕动态分配对象。

template<class Ty>
   class shared_ptr {
public:
    typedef Ty element_type;

    shared_ptr();
    shared_ptr(nullptr_t); 
    shared_ptr(const shared_ptr& sp);
    shared_ptr(shared_ptr&& sp);
    template<class Other>
        explicit shared_ptr(Other * ptr);
    template<class Other, class D>
        shared_ptr(Other * ptr, D dtor);
    template<class D>
        shared_ptr(nullptr_t, D dtor);
    template<class Other, class D, class A>
        shared_ptr(Other *ptr, D dtor, A alloc);
    template<class D, class A>
        shared_ptr(nullptr_t, D dtor, A alloc);
    template<class Other>
        shared_ptr(const shared_ptr<Other>& sp);
    template<class Other>
        shared_ptr(const shared_ptr<Other>&& sp);
    template<class Other>
        explicit shared_ptr(const weak_ptr<Other>& wp);
    template<class Other>
        shared_ptr(auto_ptr<Other>& ap);
    template<class Other, class D>
        shared_ptr(unique_ptr<Other, D>&& up);
    template<class Other>
        shared_ptr(const shared_ptr<Other>& sp, Ty *ptr);
    ~shared_ptr();
    shared_ptr& operator=(const shared_ptr& sp);
    template<class Other> 
        shared_ptr& operator=(const shared_ptr<Other>& sp);
    shared_ptr& operator=(shared_ptr&& sp);
    template<class Other> 
        shared_ptr& operator=(shared_ptr<Other>&& sp);
    template<class Other> 
        shared_ptr& operator=(auto_ptr< Other >&& ap);
    template <class Other, class D> 
        shared_ptr& operator=(const unique_ptr< Other, D>& up) = delete;
    template <class Other, class D>
        shared_ptr& operator=(unique_ptr<Other, D>&& up);
    void swap(shared_ptr& sp);
    void reset();
    template<class Other>
        void reset(Other *ptr);
    template<class Other, class D>
        void reset(Other *ptr, D dtor);
    template<class Other, class D, class A>
        void reset(Other *ptr, D dtor, A alloc);
    Ty *get() const;
    Ty& operator*() const;
    Ty *operator->() const;
    long use_count() const;
    bool unique() const;
    operator bool() const;

    template<class Other>
        bool owner_before(shared_ptr<Other> const& ptr) const;
    template<class Other>
        bool owner_before(weak_ptr<Other> const& ptr) const;
    template<class D, class Ty> 
        D* get_deleter(shared_ptr<Ty> const& ptr);
};

参数

• Ty
  由共享指针控制的类型。

• Other
  由参数指针控制的类型。

• ptr
  复制的指针。

• D
  删除器的类型。

• A
  分配算符的类型。

• dtor
  删除器

• alloc
  分配器。

• sp
  复制或移动的智能指针。

• wp
  复制或移动的弱指针。

• ap
  复制或移动的自动指针。

• up
  移动的唯一指针。

备注

模板类描述对象使用引用计数管理资源。 shared_ptr 对象持有一个指向它自己或者空指针的资源。 资源可以由一个以上的 shared_ptr 对象所拥有，当拥有特定资源的最后的shared_ptr对象被破坏，资源被释放。

当它被重新分配或重新设置时 shared_ptr 停止拥有的资源，。

模板参数 Ty可能是一个不完整的类型，除非另有说明某些成员函数。

当一个shared_ptr<Ty>对象是从一个 G* 指针类型，或 shared_ptr<G> 指针类型获取资源的，那指针类型G*必须是可以转化为Ty* 。 如果不是，代码将不进行编译。 例如：

class F {};
class G : public F {};

#include <memory>

using namespace std;

shared_ptr<G> sp0(new G);   // okay, template parameter G and argument G*
shared_ptr<G> sp1(sp0);     // okay, template parameter G and argument shared_ptr<G>
shared_ptr<F> sp2(new G);   // okay, G* convertible to F*
shared_ptr<F> sp3(sp0);     // okay, template parameter F and argument shared_ptr<G>
shared_ptr<F> sp4(sp2);     // okay, template parameter F and argument shared_ptr<F>
shared_ptr<int> sp5(new G); // error, G* not convertible to int*
shared_ptr<int> sp6(sp2);   // error, template parameter int and argument shared_ptr<F>

一个 shared_ptr 对象拥有一个资源：

• 如果构造了对该资源的指针，

• 如果它是由一个拥有那个资源shared_ptr 的对象构造的，

• 如果从 weak_ptr 类对象 构造了一个指向那资源，或者

• 如果资源被分配到它的所有权，或者shared_ptr::operator= 或者调用成员函数shared_ptr::reset。

shared_ptr 对象 拥有一个资源共享的控制块。 控制块拥有：

• 自己拥有资源的 shared_ptr 对象数

• 指向资源 weak_ptr 对象数

• 如果有的话，删除器会删除那个资源，

• 如果有，自定义分配器控制块。

shared_ptr 对象是用一个非空的指针，它指向一个非空控制块 在 shared_ptr 对象释放资源之后，它将不再拥有资源。 在 weak_ptr 对象释放资源之后，它将不在指向资源。

当该拥有资源的 shared_ptr 对象的数量变为零时，该资源被释放，或者通过删除或通过将其地址到一个删除器，这取决于如何对资源的所有权在最初创建。 当该拥有资源的 shared_ptr 对象的数量为零时，并且指向该资源的 weak_ptr 对象的数量是零，则控制块被释放，使用自定义分配给所述控制块（如果有）。

空的 shared_ptr 对象没有自己的资源和控制块。

删除器是一个有成员函数 operator() 的函数对象。 其类型必须是可配置的副本，其复制构造函数和析构函数不能引发异常。 它接受参数，要删除的对象。

有些函数接受一个参数列表，它定义了由此而来的性质 shared_ptr<Ty> 或者 weak_ptr<Ty> 对象。 可以有多种指定这些参数列表的方法：

没有参数 --结果对象是一个空的 shared_ptr 对象或者一个空的 weak_ptr 对象。

ptr 是一种用来管理 Other* 对象类型的指针。 Ty 必须是完整类型的。 如果函数失败（因为控制模块无法分配），其评估表达式 delete ptr 。

ptr, dtor 是一种用来管理或者资源的一个删除器 Other* 对象类型的指针。 如果函数失败（因为控制模块无法分配），调用 dtor(ptr) ，它必须被很好的定义。

ptr, dtor, alloc 是一种 Other* 用来管理资源，该资源的资源删除器，管理存储、分配、释放的指针。 如果函数失败（因为控制模块无法分配），调用 dtor(ptr) ，它必须被很好的定义。

sp 一种拥有要管理资源的 shared_ptr<Other> 对象。

wp 是一种用来指向管理资源 weak_ptr<Other> 对象。

ap 是一种持有指向管理资源 auto_ptr<Other> 对象。 如果函数成功调用 ap.release() ，否则它维持 ap 不变。

所有情况下，指针类型 Other* 必须是可转换为 Ty* 的。

线程安全

多线程可以同时读写不同的 shared_ptr 对象，即使当对象是共有的副本。

成员

构造函数

shared_ptr::shared_ptr	构造 shared_ptr。
shared_ptr::~shared_ptr	销毁 shared_ptr。

方法

shared_ptr::element_type	元素的类型。
shared_ptr::get	获取特定资源地址。
shared_ptr::owner_before	如果 shared_ptr 是之前指针所命令的，返回true。
shared_ptr::reset	替换拥有的资源。
shared_ptr::swap	交换两个 shared_ptr 对象。
shared_ptr::unique	测试资源是否唯一的。
shared_ptr::use_count	计数资源所有者的数量。

运算符

shared_ptr::operator boolean-type	测试资源是否存在。
shared_ptr::operator*	获取一个指定的值。
shared_ptr::operator=	替换特定资源。
shared_ptr::operator->	获取指向该指定的值的指针。

要求

页眉: <内存>

命名空间: std

请参见

参考

weak_ptr 类

C++ 标准库中的线程安全

其他资源

memory 成员