c++ - 智能指针 - weak pointer用法




为什么shared_ptr<void>合法,而unique_ptr<void>是不正确的? (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 是一个同步操作。

问题确实符合标题:我很想知道这种差异的技术原因是什么,还有理由?

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

这是因为 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 建议以下解决方案,

我从来没有尝试过这个,但也许你可以通过使用一个合适的 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.

希望有所帮助。





unique-ptr