从指代要管理的对象的各种指针类型构造新的 shared_ptr 。

T 不是数组类型时，重载 (3) 、 (4) 及 (6) 以 ptr 启用 shared_from_this ，而重载 (13) 以 r.release() 所返回的指针启用 shared_from_this 。

注解

T 不是数组类型是，重载 (3) 、 (4) 及 (6) 以 ptr 启用 shared_from_this ，而重载 (13) 以 r.release() 所返回的指针启用 shared_from_this 。

构造函数以 U* 类型指针 ptr 启用 shared_from_this ，表示它确定 U 是否拥有作为 std::enable_shared_from_this 特化的无歧义且可访问 (C++17 起)基类，而若如此，则构造函数求值该语句：

if (ptr != nullptr && ptr->weak_this.expired())
  ptr->weak_this = std::shared_ptr<std::remove_cv_t<U>>(*this,
                                  const_cast<std::remove_cv_t<U>*>(ptr));

其中 weak_this 是 std::shared_from_this 的隐藏 mutable std::weak_ptr 成员。对 weak_this 成员的赋值不是原子的，且与任何到同一对象的潜在并发访问冲突。这确保将来对 shared_from_this() 调用，将与此裸指针构造函数所创建的 shared_ptr 共享所有权。

上述解释代码中，测试 ptr->weak_this.expired() 是为确保若 weak_this 指示已有占有者则重赋值它。从 C++17 起要求此测试。

裸指针重载认定被指向对象的所有权。从而，用裸指针重载为已经为 shared_ptr 所管理对象构造 shared_ptr ，例如以 shared_ptr(ptr.get()) 很可能导致未定义行为，即使对象有导出自 std::enable_shared_from_this 的类型。

因为默认构造函数是 constexpr ，静态 shared_ptrs 作为静态非局部初始化的一部分初始化，在任何动态初始化开始前。这使得在任何静态对象的构造函数中使用 shared_ptr 是安全的。

C++11 和 C++14 中，从 std::unique_ptr<T[]> 构造 std::shared_ptr<T> 是合法的：

std::unique_ptr<int[]> arr(new int[1]);
std::shared_ptr<int> ptr(std::move(arr));

因为 shared_ptr 从 unique_ptr 获得其删除器（ std::default_delete<T[]> 对象），故能正确解分配数组。

C++17 中这不再受允许。应当使用替代的数组形式 std::shared_ptr<T[]> 。

参数

异常

示例

#include <memory>
#include <iostream>
 
struct Foo {
    Foo() { std::cout << "Foo...\n"; }
    ~Foo() { std::cout << "~Foo...\n"; }
};
 
struct D { 
    void operator()(Foo* p) const {
        std::cout << "Call delete from function object...\n";
        delete p;
    }
};
 
int main()
{
    {
        std::cout << "constructor with no managed object\n";
        std::shared_ptr<Foo> sh1;
    }
 
    {
        std::cout << "constructor with object\n";
        std::shared_ptr<Foo> sh2(new Foo);
        std::shared_ptr<Foo> sh3(sh2);
        std::cout << sh2.use_count() << '\n';
        std::cout << sh3.use_count() << '\n';
    }
 
    {
        std::cout << "constructor with object and deleter\n";
        std::shared_ptr<Foo> sh4(new Foo, D());
        std::shared_ptr<Foo> sh5(new Foo, [](auto p) {
           std::cout << "Call delete from lambda...\n";
           delete p;
        });
    }
}

constructor with no managed object
constructor with object
Foo...
2
2
~Foo...
constructor with object and deleter
Foo...
Foo...
Call delete from lambda...
~Foo...
Call delete from function object...
~Foo..

参阅