shared_ptr Class

在动态分配的对象环绕引用计数的智能指针。

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
  deleter 的类型。

• A
  分配器的类型。

• dtor
  deleter。

• alloc
  分配器。

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

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

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

• up
  移动的唯一指针。

备注

模板选件类描述使用引用管理资源的计数的对象。 shared_ptr 对象有效保存指向它拥有或保存 null 指针的资源。 资源可以由多个 shared_ptr 对象拥有；当拥有特定资源时销毁的最后一 shared_ptr 对象，该资源被释放。

当重新指派或重置时，shared_ptr 停止拥有资源。

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

当 shared_ptr<Ty> 对象构造从类型 G* 资源指针或从 shared_ptr<G>时，指针类型 G* 必须是转换为 Ty*。 如果不是，代码将不进行编译。 例如：

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

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> sp4(new G); // error, G* not convertible to int*
shared_ptr<int> sp5(sp2);   // error, template parameter int and argument shared_ptr<F>

shared_ptr 对象拥有资源：

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

• 如果从拥有该资源的 shared_ptr 对象构造完成，

• 如果从指向该资源或的 weak_ptr Class 对象构造完成

• 如果该资源所有权分配给它，与 shared_ptr::operator= 或通过调用成员函数 shared_ptr::reset。

shared_ptr 对象拥有控制块的资源共享。 控制块保存：

• 的 shared_ptr 对象数拥有该资源，

• 的 weak_ptr 对象数指向该资源，

• 该资源的 deleter，如果有)，

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

初始化使用 null 指针封送控制块的 shared_ptr 对象和不为 null。 在 shared_ptr 对象释放资源后，它不再拥有该资源。 在 weak_ptr 对象释放资源后，它不再指向该资源。

当 shared_ptr 对象数拥有资源变为零时，该资源释放，通过删除或者通过将其地址对 deleter，根据资源的所有权如何最初创建了。 当 shared_ptr 对象数拥有资源是零和的 weak_ptr 对象数量时指向该资源是零，控制块被释放，使用的自定义分配器控制块，如果有)。

空 shared_ptr 对象不属于任何资源并没有控制块。

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

某些函数采用定义生成的 shared_ptr<Ty> 或 weak_ptr<Ty> 对象的属性的参数列表。 可以指定这些参数列表的方法有多种：

没有参数--得到的对象是空 shared_ptr 对象或空 weak_ptr 对象。

ptr --类型 Other* 指针将托管资源。 Ty 必须是一个完整类型。 如果函数失败 (因为控制块不能分配) 该计算表达式 delete ptr。

ptr, dtor --类型 Other* 指针将托管资源的和该资源的一 deleter。 如果函数失败 (因为控制块不能分配)，则调用 dtor(ptr)，必须是显式定义的。

ptr, dtor, alloc --类型 Other* 指针将托管资源，该资源的一 deleter 和分配器管理必须分配和释放的任何存储。 如果函数失败 (因为控制块不能分配) 调用 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	返回 true，则此 shared_ptr 在 (或等提供的指针之前进行排序。
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->	获取一个指向该指定的值。

要求

标头： <memory>

命名空间： std

请参见

参考

weak_ptr Class

线程安全性对标准C++库中

其他资源

memory 成员