为什么shared_ptr <void>是合法的,而unique_ptr <void>是不合格的?

这个问题真的很符合标题:我很想知道这种差异的技术原因是什么,但也有理由吗?

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

这是因为std::shared_ptr实现了type-erasure,而std::unique_ptr则没有。


由于std::shared_ptr实现了types擦除,它也支持另一个有趣的属性,即。 它不需要删除器的types作为类模板的模板types参数 。 看看他们的声明:

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

其中有Deleter作为types参数,而

 template<class T> class shared_ptr; 

没有它。

现在的问题是,为什么shared_ptr实现types擦除? 那么这样做呢,因为它必须支持引用计数,为了支持它,它必须从堆中分配内存,因为它必须分配内存,所以更进一步,实现types擦除 – 这需要堆分配也。 所以基本上就是机会主义!

由于types擦除, std::shared_ptr能够支持两件事情:

  • 它可以将任何types的对象存储为void*但仍然可以通过正确调用析构函数来正确删除销毁对象
  • 删除types不会作为typesparameter passing给类模板,这意味着一点点自由而不会影响types安全性

好的。 这都是关于如何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 

你在评论中提出了一个非常有趣的问题:

在我的情况下,我将需要一个types擦除删除,但似乎也可能(以一些堆分配的代价)。 基本上,这是否意味着对于第三类智能指针实际上是一个利基点:具有types擦除的独占所有权智能指针。

其中@Steve Jessopbuild议以下解决scheme,

我从来没有真正尝试过,但也许你可以通过使用适当的std::functionunique_ptr的删除types来实现? 假设实际工作,那么你就完成了,独占所有权和一个types擦除删除器。

遵循这个build议,我实现了这个,

 using deleter_t = std::function<void(void *)>; using unique_void_ptr = std::unique_ptr<void, deleter_t>; template<typename T> auto deleter(void const * data) -> void { T const * p = static_cast<T const*>(data); std::cout << "{" << *p << "} located at [" << p << "] is being deleted.\n"; delete p; } template<typename T> auto unique_void(T * ptr) -> unique_void_ptr { return unique_void_ptr(ptr, &deleter<T>); } 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. 

希望有所帮助。

其中一个原理是shared_ptr的许多用例之一,即作为终生指标或定点标记。

这是在原来的助推文件中提到的:

 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; }; 

调用者会注册一个callback,如下所示:

 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现在可以很好地意识到它正在调用的对象的types。

这个安排释放了事件发送者的处理交叉事件的义务的订阅者(如果在active_object消失时等待被激活的callback在队列中怎么办?),也意味着不需要同步取消订阅。 weak_ptr<void>::lock是一个同步操作。