std::make_shared, std::make_shared_for_overwrite
来自cppreference.com
< cpp | memory | shared ptr
| 在标头 <memory> 定义
|
||
| template< class T, class... Args > shared_ptr<T> make_shared( Args&&... args ); |
(1) | (C++11 起) (T 非数组) |
template< class T > shared_ptr<T> make_shared( std::size_t N ); |
(2) | (C++20 起) (T 为 U[]) |
| template< class T > shared_ptr<T> make_shared(); |
(3) | (C++20 起) (T 为 U[N]) |
| template< class T > shared_ptr<T> make_shared( std::size_t N, const std::remove_extent_t<T>& u ); |
(4) | (C++20 起) (T 为 U[]) |
| template< class T > shared_ptr<T> make_shared( const std::remove_extent_t<T>& u ); |
(5) | (C++20 起) (T 为 U[N]) |
template< class T > shared_ptr<T> make_shared_for_overwrite(); |
(6) | (C++20 起) (T 非 U[]) |
| template< class T > shared_ptr<T> make_shared_for_overwrite( std::size_t N ); |
(7) | (C++20 起) (T 为 U[]) |
1) 以 args 为
T 的构造函数实参列表，构造 T 类型的对象并将它包装于 std::shared_ptr。对象如同用表达式 ::new (pv) T(std::forward<Args>(args)...) 构造，其中 pv 是指向适合保有 T 类型对象的存储的内部 void* 指针。存储典型地大于 sizeof(T)，以对共享指针控制块和 T 对象使用一次分配。此函数所调用的 std::shared_ptr 构造函数以启用以指向新构造的 T 类型对象指针调用 shared_from_this。此重载只有在 T 不是数组类型时才会参与重载决议。2,3) 同 (1)，但所构造的对象是可能多维的数组，其 std::remove_all_extents_t<T> 类型的非数组元素如同以布置 new 表达式 ::new(pv) std::remove_all_extents_t<T>() 值初始化。重载 (2) 创建第一维上大小为 N 的数组。数组元素以其地址递增顺序初始化，而当其生存期结束时，以原本构造顺序的逆序销毁。
4,5) 同 (2,3)，但每个元素从默认值 u 初始化。若
U 不是数组类型，则这如同以如 (1) 中的布置 new 表达式进行；否则，这如同以如同 (1) 中的布置 new 表达式，从来自 u 的对应元素初始化（可能多维的）数组的每个非数组元素。重载 (4) 创建第一维上大小为 N 的数组。数组元素以其地址递增顺序初始化，而当其生存期结束时，以原本构造顺序的逆序销毁。每种情况下，均将用 p->~X() 销毁对象（或若 T 为数组类型则为其各个元素） (C++20 起)，其中 p 是指向对象的指针，而 X 是该对象的类型。
参数
| args | - | 将用以构造 T 实例的实参列表
|
| N | - | 要使用的数组大小 |
| u | - | 用以初始化数组每个元素的初值 |
返回值
类型 T 实例的 std::shared_ptr。
异常
可能抛出 std::bad_alloc 或任何 T 构造函数所抛的异常。若抛出异常，则函数无效果。若异常在数组的构造中抛出，则已初始化元素以逆序销毁。 (C++20 起)
注解
此函数可用作 std::shared_ptr<T>(new T(args...)) 的替代品。得失是：
- std::shared_ptr<T>(new T(args...)) 进行至少二次分配（一次为
T而另一次为共享指针的控制块），而 std::make_shared<T> 典型地仅进行一次分配（标准推荐但不要求如此，所有已知实现均如此）。 - 若在所有共享拥有者的生存期结束后仍有任何 std::weak_ptr 引用
std::make_shared所创建的控制块，则T所占有的内存持续存在，直至所有弱拥有者亦被销毁，若 sizeof(T) 较大则这可能是不想要的行为。 - 若在可访问
T的非公开构造函数的语境中执行，std::shared_ptr<T>(new T(args...)) 可能调用它，而std::make_shared要求对被选择构造函数的公开访问。 - 不同于 std::shared_ptr 构造函数，
std::make_shared不允许自定义删除器。 -
std::make_shared使用 ::new，故若用类特定的 operator new 设置了任何特殊行为，则它将异于 std::shared_ptr<T>(new T(args...))。
|
(C++20 前) |
|
(C++17 前) |
构造函数以 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 起要求此测试。
| 功能特性测试宏 | 值 | 标准 | 功能特性 |
|---|---|---|---|
__cpp_lib_shared_ptr_arrays |
201707L | (C++20) | std::make_shared 的数组支持；重载 (2-5)
|
__cpp_lib_smart_ptr_for_overwrite |
202002L | (C++20) | 进行默认初始化的智能指针创建 (std::allocate_shared_for_overwrite, std::make_shared_for_overwrite, std::make_unique_for_overwrite)；重载 (6,7)
|
示例
运行此代码
#include <iostream> #include <memory> #include <type_traits> #include <vector> struct C { // < 需要构造函数 (C++20 前) C(int i) : i(i) {} C(int i, float f) : i(i), f(f) {} int i; float f{}; }; int main() { // 为 `sp1` 的类型使用 `auto` auto sp1 = std::make_shared<C>(1); // 重载 (1) static_assert(std::is_same_v<decltype(sp1), std::shared_ptr<C>>); std::cout << "sp1->{ i:" << sp1->i << ", f:" << sp1->f << " }\n"; // 明确 `sp2` 的类型 std::shared_ptr<C> sp2 = std::make_shared<C>(2, 3.0f); // 重载 (1) static_assert(std::is_same_v<decltype(sp2), std::shared_ptr<C>>); static_assert(std::is_same_v<decltype(sp1), decltype(sp2)>); std::cout << "sp2->{ i:" << sp2->i << ", f:" << sp2->f << " }\n"; // 指向值初始化的 float[64] 的 shared_ptr；重载 (2): std::shared_ptr<float[]> sp3 = std::make_shared<float[]>(64); // 指向值初始化的 long[5][3][4] 的 shared_ptr；重载 (2): std::shared_ptr<long[][3][4]> sp4 = std::make_shared<long[][3][4]>(5); // 指向值初始化的 short[128] 的 shared_ptr；重载 (3): std::shared_ptr<short[128]> sp5 = std::make_shared<short[128]>(); // 指向值初始化的 int[7][6][5] 的 shared_ptr；重载 (3): std::shared_ptr<int[7][6][5]> sp6 = std::make_shared<int[7][6][5]>(); // 指向 double[256] 的 shared_ptr，其各元素均为 2.0；重载 (4): std::shared_ptr<double[]> sp7 = std::make_shared<double[]>(256, 2.0); // 指向 double[7][2] 的 shared_ptr，其各 double[2] 元素均为 {3.0, 4.0}；重载 (4): std::shared_ptr<double[][2]> sp8 = std::make_shared<double[][2]>(7, {3.0, 4.0}); // 指向 vector<int>[4] 的 shared_ptr，其各向量的内容均为 {5, 6}；重载 (4): std::shared_ptr<std::vector<int>[]> sp9 = std::make_shared<std::vector<int>[]>(4, {5, 6}); // 指向 float[512] 的 shared_ptr，其各元素均为 1.0；重载 (5): std::shared_ptr<float[512]> spA = std::make_shared<float[512]>(1.0); // 指向 double[6][2] 的 shared_ptr，其各 double[2] 元素均为 {1.0, 2.0}；重载 (5): std::shared_ptr<double[6][2]> spB = std::make_shared<double[6][2]>({1.0, 2.0}); // 指向 vector<int>[4] 的 shared_ptr，其各向量的内容均为 {5, 6}；重载 (5): std::shared_ptr<std::vector<int>[4]> spC = std::make_shared<std::vector<int>[4]>({5, 6}); }
输出：
sp1->{ i:1, f:0 }
sp2->{ i:2, f:3 }参阅
构造新的 shared_ptr (公开成员函数) | |
| 创建管理一个用分配器分配的新对象的共享指针 (函数模板) | |
| (C++11) |
允许对象创建指代自身的 shared_ptr (类模板) |
| (C++14)(C++20) |
创建管理一个新对象的独占指针 (函数模板) |
| 分配函数 (函数) |