std::shared_ptr<T>:: shared_ptr

从多种指针类型构造新的 shared_ptr ，这些指针指向需要管理的对象。

当 T 不是数组类型时，重载 (3,4,6) 允许通过 ptr 使用 shared_from_this ，而重载 (13) 允许通过 r. release ( ) 返回的指针使用 shared_from_this 。

参数

后置条件

异常

注释

构造函数通过类型为 U* 的指针 ptr 启用 shared_from_this 意味着：它会判断 U 是否具有 明确且可访问的 (C++17 起) 基类，且该基类是 std::enable_shared_from_this 的特化；若满足条件，则构造函数会执行
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 的赋值操作不是原子性的，会与同一对象可能存在的并发访问产生冲突。这确保了后续对 shared_from_this() 的调用能够与通过此裸指针构造函数创建的 std::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_ptr 会作为 静态非局部初始化 的一部分，在任何动态非局部初始化开始之前完成初始化。这使得在任何静态对象的构造函数中使用 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 从其 std::unique_ptr 获取删除器（一个 std:: default_delete < T [ ] > 对象），该数组将被正确释放。

这在 C++17 中不再被允许。应改用数组形式 std:: shared_ptr < T [ ] > 。

示例

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

1) constructor with no managed object
2) constructor with object
Foo::Foo(10)
sh2.use_count(): 1
sh2.use_count(): 2
sh3.use_count(): 2
Foo::~Foo(), id=10
3) constructor with object and deleter
Foo::Foo(11)
Foo::Foo(12)
Call delete from lambda... p->id=12
Foo::~Foo(), id=12
Call delete from function object. Foo::id=11
Foo::~Foo(), id=11

缺陷报告

下列行为变更缺陷报告被追溯应用于先前发布的 C++ 标准。

参见