C++ 中 make_shared 和普通 shared_ptr 的区别

Question

std::shared_ptr<Object> p1 = std::make_shared<Object>("foo");
std::shared_ptr<Object> p2(new Object("foo"));

很多 google 和 stackoverflow 帖子都在这上面，但我不明白为什么 make_shared 比直接使用 shared_ptr 更有效。

有人可以逐步解释我创建的对象和两者完成的操作的顺序，以便我能够理解make_shared 的效率如何。上面我举了一个例子供参考。

Answer 1

不同之处在于std::make_shared 执行一次堆分配，而调用std::shared_ptr 构造函数执行两次。

堆分配发生在哪里？

std::shared_ptr 管理两个实体：

• 控制块（存储元数据，例如引用计数、类型擦除删除器等）
• 被管理的对象

std::make_shared 执行单个堆分配，占控制块和数据所需的空间。在另一种情况下，new Obj("foo") 为托管数据调用堆分配，std::shared_ptr 构造函数为控制块执行另一个。

如需更多信息，请查看cppreference@的实施说明。

更新一：异常安全

注意 (2019/08/30)：由于函数参数的求值顺序发生了变化，这从 C++17 开始不是问题。具体来说，函数的每个参数都需要在评估其他参数之前完全执行。

由于 OP 似乎想知道事物的异常安全方面，我更新了我的答案。

考虑这个例子，

void F(const std::shared_ptr<Lhs> &lhs, const std::shared_ptr<Rhs> &rhs) { /* ... */ }

F(std::shared_ptr<Lhs>(new Lhs("foo")),
  std::shared_ptr<Rhs>(new Rhs("bar")));

由于 C++ 允许对子表达式进行任意求值顺序，因此一种可能的顺序是：

1. new Lhs("foo"))
2. new Rhs("bar"))
3. std::shared_ptr<Lhs>
4. std::shared_ptr<Rhs>

现在，假设我们在第 2 步抛出了一个异常（例如，内存不足异常，Rhs 构造函数抛出了一些异常）。然后我们丢失了在第 1 步分配的内存，因为没有任何机会可以清理它。这里问题的核心是原始指针没有立即传递给std::shared_ptr 构造函数。

解决此问题的一种方法是在单独的行上执行它们，这样就不会发生这种任意排序。

auto lhs = std::shared_ptr<Lhs>(new Lhs("foo"));
auto rhs = std::shared_ptr<Rhs>(new Rhs("bar"));
F(lhs, rhs);

解决这个问题的首选方法当然是改用std::make_shared。

F(std::make_shared<Lhs>("foo"), std::make_shared<Rhs>("bar"));

更新二：std::make_shared的缺点

引用Casey的cmets：

由于只有一次分配，所以在控制块不再使用之前，指针对象的内存不能被释放。 weak_ptr 可以使控制块无限期地保持活动状态。

为什么weak_ptrs 的实例使控制块保持活动状态？

weak_ptrs 必须有一种方法来确定托管对象是否仍然有效（例如，lock）。他们通过检查拥有托管对象的shared_ptrs 的数量来做到这一点，托管对象存储在控制块中。结果是控制块一直处于活动状态，直到 shared_ptr 计数和 weak_ptr 计数都达到 0。

返回std::make_shared

由于std::make_shared 为控制块和托管对象进行了单个堆分配，因此无法独立地为控制块和托管对象释放内存。我们必须等到我们可以释放控制块和托管对象，这恰好是直到没有shared_ptrs 或weak_ptrs 活着。

假设我们通过new 和shared_ptr 构造函数为控制块和托管对象执行了两次堆分配。然后我们在没有shared_ptrs 存活时释放托管对象的内存（可能更早），并在没有weak_ptrs 存活时释放控制块的内存（可能稍后）。

Answer 2

除了已经提到的之外，还有另一种情况，两种可能性不同：如果您需要调用非公共构造函数（受保护的或私有的），make_shared 可能无法访问它，而带有新作品很好。

class A
{
public:

    A(): val(0){}

    std::shared_ptr<A> createNext(){ return std::make_shared<A>(val+1); }
    // Invalid because make_shared needs to call A(int) **internally**

    std::shared_ptr<A> createNext(){ return std::shared_ptr<A>(new A(val+1)); }
    // Works fine because A(int) is called explicitly

private:

    int val;

    A(int v): val(v){}
};

Answer 3

共享指针既管理对象本身，也管理一个包含引用计数和其他内务数据的小对象。 make_shared 可以分配一个内存块来保存这两个；从指向已分配对象的指针构造共享指针将需要分配第二个块来存储引用计数。

除了这种效率，使用make_shared意味着你根本不需要处理new和原始指针，提供更好的异常安全性——分配对象后不可能抛出异常，但是在将其分配给智能指针之前。

Answer 4

我发现 std::make_shared 存在一个问题，它不支持私有/受保护的构造函数

Answer 5

如果您需要对 shared_ptr 控制的对象进行特殊的内存对齐，则不能依赖 make_shared，但我认为这是不使用它的唯一一个好理由。

Answer 6

Shared_ptr: 执行两次堆分配

1. 控制块（引用计数）
2. 被管理的对象

Make_shared: 只执行一次堆分配

1. 控制块和对象数据。

Answer 7

我认为 mpark 先生回答的异常安全部分仍然是一个有效的问题。像这样创建shared_ptr时：shared_ptr(new T)，新的T可能会成功，而shared_ptr的控制块分配可能会失败。在这种情况下，新分配的 T 将泄漏，因为 shared_ptr 无法知道它是就地创建的并且可以安全地删除它。还是我错过了什么？我认为更严格的函数参数评估规则在这里没有任何帮助......

Answer 8

关于效率和分配的时间，我在下面做了这个简单的测试，我通过这两种方式（一次一个）创建了很多实例：

for (int k = 0 ; k < 30000000; ++k)
{
    // took more time than using new
    std::shared_ptr<int> foo = std::make_shared<int> (10);

    // was faster than using make_shared
    std::shared_ptr<int> foo2 = std::shared_ptr<int>(new int(10));
}

问题是，与使用 new 相比，使用 make_shared 花费了两倍的时间。因此，使用 new 有两个堆分配，而不是使用 make_shared 的一个。也许这是一个愚蠢的测试，但它不是表明使用 make_shared 比使用 new 需要更多时间吗？当然，我说的只是使用的时间。