Question

我将“不同类型的实例”存储为“共享所有权”。这就是我目前所做的事情：

class Destructible {
public:
    virtual ~Destructible() = default;
};

// UGLY
class MyType1 : public Destructible { ... };
class MyTypeN : public Destructible { ... };

class Storage {
    std::vector<std::shared_ptr<Destructible>> objects_;
    ...
}

我希望切换到boost::any，删除所有这些一致性，并获得存储真正任何类型的实例的能力。我也喜欢boost::any界面和boost::any_cast。

但是我的类型不满足ValueType要求，它们不可复制。这个问题的最佳解决方案（最好是现有的）是什么？类似shared_any_ptr的东西，在创建时捕获析构函数，具有类型擦除，引用计数器，可以any_cast。

编辑：boost::any允许使用move进行创建，但我不想移动和使用指针。 Edit2：我也广泛使用make_shared，因此make_shared_any_ptr会派上用场。

Answer 1

这对共享指针来说并不棘手。我们甚至可以避免多次分配。

struct any_block {
  any_block(any_block const&)=delete;
  template<class T>
  T* try_get() {
    if (!info || !ptr) return nullptr;
    if (std::type_index(typeid(T)) != std::type_index(*info)) return nullptr;
    return static_cast<T*>(ptr);
  }
  template<class T>
  T const* try_get() const {
    if (!info || !ptr) return nullptr;
    if (std::type_index(typeid(T)) != std::type_index(*info)) return nullptr;
    return static_cast<T const*>(ptr);
  }
  ~any_block() {
    cleanup();
  }
protected:
  void cleanup(){
    if (dtor) dtor(this);
    dtor=0;
  }
  any_block() {}
  std::type_info const* info = nullptr;
  void* ptr = nullptr;
  void(*dtor)(any_block*) = nullptr;
};
template<class T>
struct any_block_made:any_block {
  std::aligned_storage_t<sizeof(T), alignof(T)> data;
  any_block_made() {}
  ~any_block_made() {}
  T* get_unsafe() {
    return static_cast<T*>((void*)&data);
  }
  template<class...Args>
  void emplace(Args&&...args) {
    ptr = ::new((void*)get_unsafe()) T(std::forward<Args>(args)...);
    info = &typeid(T);
    dtor = [](any_block* self){
      static_cast<any_block_made<T>*>(self)->get_unsafe()->~T();
    };
  }
};
template<class D>
struct any_block_dtor:any_block {
  std::aligned_storage_t<sizeof(D), alignof(D)> dtor_data;
  any_block_dtor() {}
  ~any_block_dtor() {
    cleanup();
    if (info) dtor_unsafe()->~D();
  }
  D* dtor_unsafe() {
    return static_cast<D*>((void*)&dtor_data);
  }
  template<class T, class D0>
  void init(T* t, D0&& d) {
    ::new( (void*)dtor_unsafe() ) D(std::forward<D0>(d));
    info = &typeid(T);
    ptr = t;
    dtor = [](any_block* s) {
      auto* self = static_cast<any_block_dtor<D>*>(s);
      (*self->dtor_unsafe())( static_cast<T*>(self->ptr) );
    };
  }
};

using any_ptr = std::shared_ptr<any_block>;
template<class T, class...Args>
any_ptr
make_any_ptr(Args&&...args) {
  auto r = std::make_shared<any_block_made<T>>();
  if (!r) return nullptr;
  r->emplace(std::forward<Args>(args)...);
  return r;
}
template<class T, class D=std::default_delete<T>>
any_ptr wrap_any_ptr( T* t, D&& d = {} ) {
    auto r = std::make_shared<any_block_dtor<std::decay_t<D>>>();
    if (!r) return nullptr;
    r->init( t, std::forward<D>(d) );
    return r;
}

您必须实施any_cast，但使用try_get<T>则应该很容易。

可能会出现上述无法解决的const T等问题。

template<class T>
std::shared_ptr<T>
crystalize_any_ptr( any_ptr ptr ) {
  if (!ptr) return nullptr;
  T* pt = ptr->try_get<T>();
  if (!pt) return nullptr;
  return {pt, ptr}; // aliasing constructor
}

如果类型匹配而不复制任何内容，则可以使用any_ptr并将其转换为shared_ptr<T>。

live example

您会注意到any_block_made和any_block_dtor的相似程度。我相信这就是为什么std库中至少有一个主要的shared_ptr重用了删除器所在的make_shared本身。

我可能会做类似的事情，并在这里减少二进制文件大小。此外，T和D的{{1}} / any_block_made参数实际上只是关于我们使用的内存块的大小和对齐情况，以及删除的确切类型帮助器我存储在父项的any_block_dtor指针中。带有COMDAT折叠的编译器/链接器（MSVC或GOLD）可以消除这里的二进制膨胀，但是我可以自己做一些小心点。

非复制std :: shared_ptr <boost :: any>？

1 个答案: