std::shared_ptr 控制块中的虚函数答案

【问题标题】：virtual function in std::shared_ptr's control blockstd::shared_ptr 控制块中的虚函数
【发布时间】：2018-10-23 18:40:07
【问题描述】：

shared::ptr我发现的实现是这样写的

namespace detail {
   struct deleter_base {
      virtual ~deleter_base() {}
      virtual void operator()( void* ) = 0;
   };
   template <typename T>
   struct deleter : deleter_base {
      virtual void operator()( void* p ) {
         delete static_cast<T*>(p);
      }
   };
}
template <typename T>
class simple_ptr {
   T* ptr;
   detail::deleter_base* deleter;
public:
   template <typename U>
   simple_ptr( U* p ) {
      ptr = p;
      deleter = new detail::deleter<U>();
   }
   ~simple_ptr() {
      (*deleter)( ptr );
      delete deleter;
   }
};

我的问题是

1) 为什么我们需要这样的结构（我的意思是类型擦除技术），我们不能把它作为删除器（见下面的代码）吗？在这里有一个虚函数的目的是什么，据我所知，如果它不是虚拟的，它无论如何都会在正确的类型上调用delete（即在Bar 上输入std::shared_ptr<Foo>(new Bar)），因为simple_ptr 已模板化构造函数。

template <typename T>
   struct deleter {
      void operator()( void* p ) {
         delete static_cast<T*>(p);
      }
   };

2) 为什么我们需要在基类中使用虚拟析构函数？仅仅是因为它包含一个虚函数还是我们的删除器也必须有虚析构函数？

【问题讨论】：

您的第二个问题在这里得到解答：stackoverflow.com/questions/461203/…
您的示例适用于只需要一个函数即可工作的琐碎删除器，但如果您想要一个具有某种状态或持久数据的删除器，那么您的示例将不起作用，而多态选项会。
您的deleter<T> 不能存储在simple_ptr 中，因为没有任何类型（除了void*）可以为任何deleter<T> 存储T。在void* 中，它不能被调用。所以我不确定你在问什么。
@Yakk-AdamNevraumont 啊，非常感谢，我没有意识到我什至不能用这种方式存储它，现在我清楚为什么我们需要这个抽象类了 :)

标签： c++ templates shared-ptr virtual-functions

【解决方案1】：

共享指针类型擦除销毁，因为它们已经必须处理引用计数。一直到类型擦除销毁并没有那么昂贵。

如果您希望能够将指向 T 的共享指针转换为指向 void 的共享指针，则需要类型擦除销毁，这有时很有用。一般来说，它不需要您存储的数据具有虚拟析构函数。

此外，它允许别名共享指针指向内共享指针拥有的资源。

你的删除器显然不起作用；因为它缺少一个通用的基类，所以它通常只能存储在一个void* 中，你不能用(ptr) 调用void*。

忽略您的shared::ptr，如果我们查看工业质量std::shared_ptr，我们会发现引用控制块在其末尾存储了类型擦除删除器，如果您make_shared，它会替换带有对象实例的类型擦除删除器。

struct rc_block {
  std::atomic<std::size_t> strong;
  std::atomic<std::size_t> weak;
  virtual void cleanup() = 0;
  virtual ~rc_block() {}
};

template<class T>
struct maked_rc_block final {
  std::atomic<std::size_t> strong = 1;
  std::atomic<std::size_t> weak = 0;
  std::aligned_storage<sizeof(T), alignof(T)> t;
  template<class... Args>
  maked_rc_block(Args&&...args) {
    ::new( (void*)&t ) T(std::forward<Args>(args)...);
  }
  void cleanup() override {
    ((T*)&t)->~T();
  }
};

template<class F>
struct action_rc_block final {
  std::atomic<std::size_t> strong = 1;
  std::atomic<std::size_t> weak = 0;
  F f;
  void cleanup() { f(); }
  template<class IN>
  actoin_rc_block(IN&& in):f(std::forward<IN>(in)) {}
};
template<class F>
action_rc_block(F)->action_rc_block<F>;

template<class T>
struct simple_shared {
  T* ptr = 0;
  rc_block* counters = 0;
  simple_shared( simple_shared const& o ):
    ptr(o.ptr), counters(o.counters)
  { if (counters) ++(counters->strong); }
  ~simple_shared() {
    if (counters && --(counters->strong)) {
      delete counters;
    }
  }
  template<class U>
  simple_shared(U* in):
    ptr(in),
    counters( new action_rc_block{[in]{ delete in; }} )
  {}
  // explicit deleter
  template<class U, class D>
  simple_shared(U* in, D&& d):
    ptr(in),
    counters( new action_rc_block{[in,d=std::forward<D>(d)]{ d(in); }} )
  {}
  template<class U, class V>
  simple_shared(simple_shared<U> const& alias_this, V* v):
    ptr(v),
    counters(alias_this.counters)
  {
    if(counters) ++(counters->strong);
  }
  template<class U>
  simple_shared( maked_rc_block<U>* c ):
    ptr( c?(T*)&c.t:nullptr ),
    counters(c)
  {}
};
template<class T, class...Args>
simple_shared<T> make_simple_shared( Args&&... args ) {
  auto* counter = new make_rc_block<T>( std::forward<Args>(args)... );
  return {counter};
}

我对原子的使用既快又松，但我希望你明白。

【讨论】：

【解决方案2】：

拥有智能指针的设计空间大而多样；但许多设计选择意味着严格的约束。

对于任何共享拥有的智能指针，将 lambda do 存储到 delete static_cast<T*>(p);（或“类型擦除”）的唯一替代方法是对组中最后拥有的智能指针使用 delete。

如果您根本不允许转换，并且所有所有者都具有完全相同的指针值，则可以这样做。这样，可以保证销毁最后一个实例总是产生相同的效果。

如果您甚至允许从派生到基转换，则意味着只有在托管对象具有虚拟析构函数时，结果才会被明确定义。您可以在指针值上支持static_cast 和dynamic_cast。

这意味着您不能拥有不属于智能指针类型的自定义删除器对象。

除非智能指针具有不同的类型，否则您不能构造可以将控制块分配为对象的一部分（如make_shared）的拥有智能指针。

您没有通用的“别名构造函数”，因此您无法获得指向任意子对象或原始对象拥有的对象的拥有智能指针。（因此，如果您有一个指向集合的智能指针，则不能将拥有的智能指针指向集合中的某个元素，从而在需要该元素时使该集合保持活动状态。）

走这条路（避免抽象 delete p; 的成本）将使控制块更小，删除速度更快，但它也可能导致不同不兼容类型的专用智能指针的扩散，因为在实践中经常需要其他操作。

【讨论】：