为什么shared_ptr<void>是合法的，而unique_ptr<void>则是不合法的？

Question

为什么shared_ptr<void>是合法的，而unique_ptr<void>则是不合法的？

123

问题实际上与标题相符：我很好奇知道这种差异的技术原因，以及背后的逻辑？

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

- Ad N

2个回答

7

其中一个理由是在许多使用情况下的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>，所以事件发射器现在可以完全不必关心它所调用的对象类型。

这种安排解除了事件发射器订阅者处理交叉情况（如果回调正在等待执行而活动对象却消失了会怎么样？）的义务，同时也意味着无需同步取消订阅。 weak_ptr<void>::lock是一个同步操作。

- Richard Hodges

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Nawaz · Accepted Answer

这是因为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能否将对象存储为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提出了以下解决方案：

我实际上从未尝试过这个，但也许你可以通过在unique_ptr中使用适当的std::function作为删除器类型来实现这一点。假设这确实有效，那么你就完成了，既有独占所有权，又有类型擦除的删除器。

根据这个建议，我实现了这个功能（尽管它没有使用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的替代方法

为什么shared_ptr<void>是合法的，而unique_ptr<void>则是不合法的？

那么，为什么shared_ptr要实现类型擦除呢？

那么，为什么`shared_ptr`要实现类型擦除呢？