C++ std::make_shared 详解

输出结果

Foo constructor
Foo.x = 42
Foo destructor

(2) 创建数组（C++20 及更高版本支持）

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int[]> arr = std::make_shared<int[]>(5);
    for (int i = 0; i < 5; ++i) arr[i] = i * 2;
    for (int i = 0; i < 5; ++i) std::cout << arr[i] << " ";
    return 0;
}

输出

0 2 4 6 8 

注意：C++11/14 不支持 std::make_shared 创建数组，需使用 std::shared_ptr<int[]>(new int[5])。

(3) 与 std::shared_ptr<T>(new T(...)) 对比

#include <iostream>
#include <memory>

struct Bar {
    Bar() { std::cout << "Bar constructor\n"; }
    ~Bar() { std::cout << "Bar destructor\n"; }
};

int main() {
    std::shared_ptr<Bar> p1 = std::make_shared<Bar>(); // 推荐
    std::shared_ptr<Bar> p2(new Bar);                 // 不推荐
}

分析：std::make_shared<Bar>() 只分配 一次 内存；std::shared_ptr<Bar>(new Bar) 需要两次分配。

5. 实现原理

大致实现可以如下：

template<typename T, typename... Args>
std::shared_ptr<T> make_shared(Args&&... args) {
    return std::shared_ptr<T>(new T(std::forward<Args>(args)...));
}

但实际上，标准库的实现比这更复杂，因为它优化了 控制块和对象的联合分配。

6. 何时不适用 std::make_shared

虽然 std::make_shared 有很多优点，但在以下情况不适用：

1. 自定义删除器：std::make_shared 不能传递自定义删除器，只能使用 std::shared_ptr<T>(new T, custom_deleter)。
2. 动态数组（C++20 之前）：std::make_shared 不支持 std::shared_ptr<T[]>，直到 C++20 才支持。
3. 控制生命周期的特殊需求：例如，如果 T 需要精确控制 何时析构，可能需要手动 new 并使用 std::shared_ptr<T>。

7. 总结

8. 模板参数 <> 和构造参数 ()

std::make_shared<T>(...) 是一个模板函数：

• <> 里面填充：要创建的对象类型 T
• () 里面填充：传递给 T 构造函数的参数

<> 内可放内容

• 普通类型（如 int）
• 自定义类、结构体、联合体
• 模板类（如 Box<int>）
• 数组类型（C++20 及以上）

() 内可放内容

• 零个参数（默认构造）
• 一个或多个参数
• 初始化列表
• 指针、引用等

9. 在 std::packaged_task 中的用法

auto task = std::make_shared<std::packaged_task<return_type()>>(
    std::bind(std::forward<F>(f), std::forward<Args>(args)...) );

此语法用于高效封装异步任务，并支持共享管理。std::make_shared 创建 std::shared_ptr<T> 并高效分配内存，std::packaged_task 封装任务，可延迟执行并获取 future 结果。

示例代码

#include <iostream>
#include <memory>
#include <future>
#include <functional>
#include <thread>

void work(int x, int y) {
    std::cout << "Work: " << x + y << std::endl;
}

int main() {
    auto task = std::make_shared<std::packaged_task<void()>>(
        std::bind(work, 10, 20));
    std::thread t([task]() { (*task)(); });
    t.join();
    return 0;
}

输出

Work: 30