c++ - 如何管理 "shortest of"类型的生命周期？

Question

当一个对象只有一个父对象时，我们使用组合，它应该关心对象的生命周期。同样的情况我们使用unique_ptr，但是对象可以是nullptr。

当多个外部实体可能需要我们的对象时，我们使用 shared_ptr，因此它的生命周期会延长，直到最后一个外部实体失去兴趣。

这里想问一下另外一个人生境遇。 如果对象需要在多个持续时间中最短存活怎么办？

这是一个例子。让我们有一个一次性定时器，它存储一个仿函数并在计数完成后执行它。这对我来说很有意义*，这个计时器对象在以下之后被销毁:

1. fulfilling its task - therefore it should be able to destroy istelf

 or

2. the parent loosing interest in the timer - so the parent should be able to 
     destroy the object as well

目前，我使用带有唯一指针的笨拙实现。这个问题的好的模式/指南/实现是什么？

_{* 原因:1) 仿函数可能拥有一些其他资源2) 计时器可能已设置为非常大的数字，然后被放弃3)如果父级已经被销毁，我们一般不想调用它的回调}

Answer 1

这里存在严重的并发和重入问题。

当两段或多段代码有权删除指针时，任何一段代码都不能可靠地取消对该指针的引用，因为在这样做的同时，另一段代码可能会破坏它。

同样，在任何其他非本地(比如函数调用)运行时，您检查您拥有所有权的任何分支都可能变得陈旧，即使没有并发也是如此。

我们可以解决这些问题。

template<class T>
struct shared_destroyable {
  std::shared_ptr<T> lock() const {
    return atomic_load<T>(ptr.get());
  }
  explicit operator bool() const { return (bool)lock; }
  void reset( std::shared_ptr<T> pin = {} ) {
    atomic_store(ptr.get(), std::move(pin));
  }
  shared_destroyable(std::shared_ptr<T> pin):
    ptr(std::make_shared<std::shared_ptr<T>>(std::move(pin))
  {}
  shared_destroyable()=default;
  shared_destroyable(shared_destroyable&&)=default;
  shared_destroyable(shared_destroyable const&)=default;
  shared_destroyable& operator=(shared_destroyable&&)=default;
  shared_destroyable& operator=(shared_destroyable const&)=default;
private:
  std::shared_ptr<std::shared_ptr<T>> ptr;
};

这表现得像 weak_ptr shared_ptr 混合体。

如果最后一个消失，则对象被销毁。

但是，如果它们中的任何一个 .reset()，对象将在最后一个具有 lock()ed 的代码结束时被销毁它的范围。

引用的赋值变化。

所以在使用时你这样做:

if(auto sp = sd.lock()) {
  // use sp
}

并且 sp 生命周期保证持续 {} 的范围，即使有人在其中执行了 sd.reset() block ，在另一个线程中，或者当您调用其他方法时。