将 shared_ptr 转换为常规指针

Question

我们有一个函数，它返回一个新分配的对象作为输出参数（引用指针）。

MyFunc(MyObject*& obj)
{
    obj = new MyObject();
}

这样称呼：

Object* obj;
MyFunc(obj);

该函数在内部做了很多工作，并使用shared_ptr 进行内存管理。完成后，我们要返回的对象由shared_ptr 引用。我正在努力研究如何将新分配的对象作为常规指针返回。

我们希望在内部继续使用shared_ptr 以降低风险，但返回shared_ptr 似乎没有意义，因为调用者对返回的值拥有完全的所有权（被调用的函数或对象不再需要或保留对返回数据的引用），我们希望它们具有灵活性。

是否有人对允许我们在内部使用shared_ptr 但有一个常规指针接口有什么建议？谢谢

Answer 1

如果由于某种原因您不能/不想使用std::unique_ptr 或std::auto_ptr（例如，如果您在创建期间出于某种原因需要在内部拥有多个所有者，或者您的底层方法需要传递std::shared_ptr），您仍然可以通过使用自定义删除器使其与std::shared_ptr 一起使用，如下所述：https://stackoverflow.com/a/5995770/1274747

原则上，在return前完成后，将deleter切换为不实际删除实例（使deleter为“null”），然后通过shared_ptrget()返回。即使所有 shared_ptr 对象都被销毁，内存也不会被删除（因为空的删除器会跳过删除）。

cmets 中还有一个不太明显的链接，您可能会感兴趣： http://paste.ubuntu.com/23866812/ （不确定在所有情况下如果没有交换机的共享所有权，它是否真的可以工作，需要测试）

---

编辑

正如预期的那样，使用 pastebin 中链接的简单可解除删除器需要小心，因为删除器实际上被复制以存储在 std::shared_ptr 中。

但您仍然可以使用std::ref 使其工作：

MyFunc(MyObject*& obj)
{
    DisarmableDelete<MyObject> deleter;
    std::shared_ptr<MyObject> ptr(new MyObject(), std::ref(deleter));
    // do what is necessary to setup the object - protected by deleter
    // ...
    // disarm before return
    deleter._armed = false;
    obj = ptr.get();
    // deleter disarmed - object not freed
}

为了完整起见（并避免未来可能出现的断开链接），这里是来自http://paste.ubuntu.com/23866812/ 的DisarmableDelete 的实现。

template <typename T, typename Deleter = typename std::default_delete<T> >                                                                                                                              
    struct DisarmableDelete : private Deleter {                                                                                                                                                         
        void operator()(T* ptr) { if(_armed) Deleter::operator()(ptr); }                                                                                                                                
        bool _armed = true;                                                                                                                                                                             
    };        

Answer 2

这取决于谁“拥有”指针，一旦它暴露于“外部世界”。所有权本质上归结为：“谁负责稍后释放此内存？”

可以用一个简单的问题来回答：当MyFunc被调用时，调用者是否负责在完成后删除指针？

1. 如果是，那么MyFunc 需要“释放”所有权，否则shared_ptr 会在超出范围时自动删除指针。这实际上不能使用shared_ptr 来完成。您需要改用unique_ptr，并调用unique_ptr::release()。
2. 如果不是 - 如果MyFunc 将简单地使用 结果指针并在没有delete-ing 的情况下忘记它 - 那么您可以简单地使用返回“原始”指针shared_ptr::get()。您必须小心，因为这意味着 shared_ptr 仍然存在于您的代码中的其他位置。

Answer 3

我可以看到四种选择，如下所示。它们都很可怕，没有将您的所有权切换到std::unique_ptr<T> 并通过obj = ptr.release(); 返回我只能提供一个技巧，其中参数在销毁时分配给指针，但您仍然需要捕获异常并测试是否指针已分配。

#include <iostream>
#include <memory>
#include <exception>

struct foo {
  void bar() const { std::cout << this << " foo::bar()\n"; }
  ~foo() { std::cout << this << " deleted\n"; }
};

void f1(foo*& obj) {
  obj = new foo;
  // do stuff... if an exception is thrown before we return we are
  // left with a memory leak
}

void f2(foo*& obj) {
  auto holder = std::make_shared<foo>();
  // do stuff.. if an exception is thrown the pointer will be
  // correclty deleted.

  obj = holder.get(); // awesome, I have a raw pointer!
} // oops, the destructor gets called because holder went out of
  // scope... my pointer points to a deleted object.

void f3(foo*& obj) {
  auto holder = std::make_unique<foo>();
  // do stuff.. if an exception is thrown the pointer will be
  // correclty deleted.

  obj = holder.release(); // awesome, I have a raw pointer!
} // no problem whem holder goes out of scope because it does not own the pointer

void f4(foo*& obj) {
  // a super-weird hack that assigns obj upon deletion
  std::shared_ptr<foo> holder(new foo, [&obj](foo*& p){  obj = p; });
  throw std::exception();
} // no problem whem holder goes out of scope because it does not own
  // the pointer... but if an execption is throw we need to delete obj

int main() {

  foo* p1;
  f1(p1);
  p1->bar();

  foo* p2;
  f2(p2);
  // p2->bar(); // error

  foo* p3;
  f3(p3);
  p3->bar();

  foo* p4;
  try {
    f4(p4);
  } catch(...) {
    std::cout << "caught an exception... test whether p4 was assigned  it\n";
  }
  p4->bar(); // I still need to delete this thing
}

Answer 4

shared_ptr 的意义在于表达共享所有权。

任何不共享对象所有权的事物——无权延长对象生命周期，并且对象生命周期是共享所有者请求对象生命周期的联合——不应该使用shared_ptr。

在这里，您有一个shared_ptr，您将返回它。此时，您违反了shared_ptr 的假设；任何保留shared_ptr 副本的人都希望其内容可以持续多久。

同时，调用代码认为它拥有您传递给它的 MyObject* 原始指针。

这是一个滥用shared_ptr的例子。

说“我们有内存管理问题，请使用shared_ptr”并不能解决内存管理问题。正确使用 shared_ptr 需要谨慎和设计，并且设计必须是当相关对象的生命周期结束时由 2 条或更多条数据和/或代码共享。

如果内部代码不拥有指针，则应使用observer_ptr<T> 或原始T* 之类的东西（首先明确表示它不拥有该对象）。

所有权应该是明确的，并且在unique_ptr 中。如果需要，它可以调用.release() 将所有权传递给原始指针；实际上，我会将您的签名更改为采用unique_ptr&，或者让它返回unique_ptr。

当调用者想要使用其他对象生命周期管理系统时，调用者会调用.release()，或者该对象生命周期管理系统应该使用unique_ptrs（因此非常清楚获取事物的所有权）。

---

使用非黑客解决方案。

如std::shared_ptr<std::unique_ptr<T>>。在这种情况下，您共享了唯一所有权的所有权。

unique_ptr 可以从它那里获得所有权（通过.release()）。当它这样做时，所有仍然存在的shared_ptrs 的unique_ptr 也将被清除。

这会将共享的唯一所有权放在首位和中心位置，而不是将非删除器入侵到 shared_ptr 中，并让那些认为自己拥有数据所有权但没有所有权的 shared_ptr 悬空。

Answer 5

最好的方法是在内部使用unique_ptr 并在返回原始指针之前调用它的 .release() 方法。

如果你坚持在内部使用 shared_ptr，一个选项是创建它，指定一个自定义的“noop”删除器，它在 shared_ptr 被销毁时什么都不做（而不是在拥有的指针上调用 delete）。像往常一样从shared_ptr 获取原始指针（.get() 方法）。 可以在 Boost 库 (null_deleter) 中找到此类删除器的示例。
但请注意，这样做有效地“禁用”了 shared_ptr 的用处......

Answer 6

如果您在内部使用 std::shared_ptr 管理已分配对象的生命周期，并且正在返回一个原始指针以供访问并且不希望该指针影响引用计数，您可以通过调用 shared_ptr 返回原始指针。获取（）。

如果您使用 Swig 之类的工具为其他语言生成包装器，则返回智能指针可能会出现问题。