为什么shared_ptr<void>是合法的，而unique_ptr<void>是格式错误的？

Question

这个问题确实符合标题：我很想知道造成这种差异的技术原因是什么，以及原理是什么？

std::shared_ptr<void> sharedToVoid; // legal;
std::unique_ptr<void> uniqueToVoid; // ill-formed;

Answer 1

这是因为

std::shared_ptr

实现了类型擦除，而

std::unique_ptr

则没有。

---

由于

std::shared_ptr

实现了类型擦除，它还支持另一个有趣的属性，即。它不需要需要删除器的类型作为类模板的模板类型参数。看看他们的声明：

template<class T,class Deleter = std::default_delete<T> > 
class unique_ptr;

其中

Deleter

作为类型参数，而

template<class T> 
class shared_ptr;

没有。

那么，为什么

shared_ptr

要实现类型擦除？

嗯，它确实这样做了，因为它必须支持引用计数，并且为了支持这一点，它必须从堆中分配内存，并且因为无论如何它必须分配内存，所以它更进一步并实现类型擦除 -这也需要堆分配。 所以基本上这只是机会主义！

由于类型擦除，

std::shared_ptr

能够支持两件事：

• 它可以将任何类型的对象存储为

  void*

  ，但它仍然能够在销毁时正确删除对象通过正确调用其析构函数。
• 删除器的类型不会作为类型参数传递给类模板，这意味着一点自由不影响类型安全。

好吧。这就是

std::shared_ptr

的工作原理。

现在的问题是，

std::unique_ptr

可以将对象as

void*

存储吗？好吧，答案是，是——只要你传递一个合适的删除器作为参数。这是一个这样的演示：

int main()
{
    auto deleter = [](void const * data ) {
        int const * p = static_cast<int const*>(data);
        std::cout << *p << " located at " << p <<  " is being deleted";
        delete p;
    };
    
    std::unique_ptr<void, decltype(deleter)> p(new int(959), deleter);
    
} //p will be deleted here, both p ;-)

输出（在线演示）：

959 located at 0x18aec20 is being deleted

---

您在评论中问了一个非常有趣的问题：

就我而言，我需要一个类型擦除删除器，但这似乎也是可能的（以一些堆分配为代价）。基本上，这是否意味着第三种类型的智能指针实际上有一个利基市场：具有类型擦除功能的独占所有权智能指针。

@Steve Jessop建议了以下解决方案，

我从未真正尝试过这个，但也许您可以通过使用适当的

std::function

 作为 

unique_ptr

 的删除器类型来实现这一点？假设这确实有效，那么您就完成了，独占所有权和类型擦除的删除器。

按照这个建议，我实现了这个（尽管它没有使用

std::function

，因为它似乎没有必要）：

using unique_void_ptr = std::unique_ptr<void, void(*)(void const*)>;

template<typename T>
auto unique_void(T * ptr) -> unique_void_ptr
{
    return unique_void_ptr(ptr, [](void const * data) {
         T const * p = static_cast<T const*>(data);
         std::cout << "{" << *p << "} located at [" << p <<  "] is being deleted.\n";
         delete p;
    });
}

int main()
{
    auto p1 = unique_void(new int(959));
    auto p2 = unique_void(new double(595.5));
    auto p3 = unique_void(new std::string("Hello World"));
}  

输出（

在线演示）：

{Hello World} located at [0x2364c60] is being deleted.
{595.5} located at [0x2364c40] is being deleted.
{959} located at [0x2364c20] is being deleted.

为了避免裸新，您可以：

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

代替 std::make_unique

Answer 2

其中一个基本原理是

shared_ptr

 的众多用例之一 - 即作为生命周期指示器或哨兵。

这在原始的 boost 文档中提到过：

auto register_callback(std::function<void()> closure, std::shared_ptr<void> pv)
{
    auto closure_target = { closure, std::weak_ptr<void>(pv) };
    ...
    // store the target somewhere, and later....
}

void call_closure(closure_target target)
{
    // test whether target of the closure still exists
    auto lock = target.sentinel.lock();
    if (lock) {
        // if so, call the closure
        target.closure();
    }
}

哪里

closure_target

是这样的：

struct closure_target {
    std::function<void()> closure;
    std::weak_ptr<void> sentinel;
};

调用者会注册一个回调，如下所示：

struct active_object : std::enable_shared_from_this<active_object>
{
    void start() {
      event_emitter_.register_callback([this] { this->on_callback(); }, 
                                       shared_from_this());
    }

    void on_callback()
    {
        // this is only ever called if we still exist 
    }
};

因为

shared_ptr<X>

 始终可转换为 

shared_ptr<void>

，所以 event_emitter 现在可以完全不知道它回调到的对象类型。

这种安排释放了事件发射器的订阅者处理交叉情况的义务（如果队列中的回调在 active_object 消失时等待执行怎么办？），并且也意味着不需要同步取消订阅。

weak_ptr<void>::lock

 是同步操作。