为什么在boost或Standard中没有"变体"？

Question

的一个优点any了variant就是,一个不需要指定所有类型,它可能含有.我注意到,随着a类型的数量variant增加,人们倾向于any在某个时候切换,因为他们根本不再跟踪所有类型.我想之间的混合any,并variant有可能.一个可以存储" placeholder"(通过放置new)的any中aligned_storage,与在所计算的大小constexpr被存储,其可以最终功能或模板元函数,从最大的类型的样本,.另一方面,用户不需要指定any可能包含的所有类型.该any还可以扔在任何时候,如果用户将尝试存储的东西比大aligned_storage在那里.

这样的" variant_any"类是否存在？这个想法有一些固有的问题吗？

Answer 1

这是一个基本的some.

复制T/分配/移动等可以用emplace. SFINAE 使用can_store<T>可以确保只有可以some实际存储的类型才能分配给它，从而避免不必要的异常。

目前，移出会some破坏其内容，而不仅仅是移出它。还有一个some可以为空（它们是“可为空的”）。

load_from是来自另一个的“可能失败”的复制构造函数some——它在失败时返回false。我可以添加一个较小的“不能失败”some（甚至是复制/赋值运算符）的“不能失败”来完成它。

some_meta是手动虚函数表。T您以任何大小存储的每种类型都存在一个some。它存储对要使用的T类型的类型擦除操作（在本例中为复制、移动和销毁），以及有关该类型的一些数据（大小、对齐方式和类型标识）。some它可以通过比较和序列化等附加操作来增强。对于二元运算，必须考虑处理“无匹配类型”的逻辑。对于序列化之类的东西，我让它调用 free 函数serialize并deserialize在T. 在这两种情况下，我们都对什么提出了额外的要求some可以存储的内容提出了额外的要求（您可以通过一些工作来处理“也许序列化”，但这会变得混乱）。

您甚至可以想象一个系统，您可以在其中存储一组对数据（二进制和一元）执行的操作，并将所述操作捆绑在传递给某些类型的类型中。然而，此时我们正在接近 的boost类型擦除库。

namespace details {
template<std::size_t Size, std::size_t Align=0>
struct storage_helper {
  using type = std::aligned_storage_t<Size, Align>;
  enum { alignment = alignof(type), size = Size };
};
template<std::size_t Size>
struct storage_helper<Size, 0> {
  using type = std::aligned_storage_t<Size>;
  enum { alignment = alignof(type), size = Size };
};
template<std::size_t size, std::size_t align>
using storage_helper_t = typename storage_helper<size,align>::type;

template<class T>using type=T;
struct some_meta {
  type<void(void*)>* destroy;
  type<void(void* dest, void const* src)>* copy;
  type<void(void* dest, void* src)>* move;
  std::type_index type;
  size_t size;
  size_t align;
  template<class T> static some_meta const* get() {
    static const some_meta retval( create<T>() );
    return &retval;
  };
  private:
  template<class T> static some_meta create() {
    return {
        [](void* p){ ((T*)p)->~T(); },
        [](void* out, void const* in){ new(out)T(*(T*)in); },
        [](void* dest, void* src) { new(dest)T(std::move(*(T*)src)); },
        typeid(T),
        sizeof(T),
        alignof(T)
    };
  }
};
}

template<class>struct emplace_as{};

template< std::size_t size, std::size_t Align=0 >
struct some {
  enum { align = details::storage_helper<size, Align>::alignment };
  using data_type = details::storage_helper_t<size, Align>;

  template<size_t, size_t> friend struct some;
  template<class T> struct can_store :
    std::integral_constant< bool, ((align%alignof(T))==0) && sizeof(T) <= size) >
  {};

  template<size_t x, size_t a>
  static bool can_fit( some<x,a> const& o ) {
    if (x<=size && ((align%some<x,a>::align)==0)) return true; // should cause optimizations
    if (!o.meta) return true;
    if (o.meta->size > size) return false;
    if (o.meta->align > align) return false;
    return true;
  }
private:
  data_type data;
  details::some_meta const* meta = nullptr;
public:
  // true iif we are (exactly) a T
  template<class T>
  bool is() const {
      return meta && (meta->type == typeid(T));
  }

  explicit operator bool()const { return meta!=nullptr; }

  template<class T>
  T* unsafe_get() { return reinterpret_cast<T*>(&data); }

  template<class T>
  T* get() { if (is<T>()) return unsafe_get<T>(); else return nullptr; }

  void clear() { if (meta) meta->destroy(&data); meta = nullptr; }

  template<class T, class... Args>
  std::enable_if_t< can_store<T>{} >
  emplace(Args&&...args) {
    clear();

    new(&data) T(std::forward<Args>(args)...);
    meta = details::some_meta::get<T>();
  }
  some()=default;
  some(some const& o) {
    *this = o;
  }
  some(some const&&o):some(o){}
  some(some&o):some(const_cast<some const&>(o)){}
  some(some&& o) {
    *this = std::move(o);
  }

  some& operator=(some const&o) {
    if (this == &o) return *this;
    clear();
    if (o.meta) {
      o.meta->copy( &data, &o.data );
      meta=o.meta;
    }
    return *this;
  }        
  some& operator=(some &&o) {
    if (this == &o) return *this;
    clear();
    if (o.meta) {
      o.meta->move( &data, &o.data );
      meta=o.meta;
      o.clear();
    }
    return *this;
  }
  some& operator=(some const&&o) { return *this=o; }
  some& operator=(some &o) { return *this=const_cast<some const&>(o); }

  // from non-some:
  template<class T,class=std::enable_if_t<can_store<std::decay_t<T>>{}>>
  some(T&& t){
    emplace<std::decay_t<T>>(std::forward<T>(t));
  }
  template<class T, class...Args,class=std::enable_if_t<can_store<T>{}>>
  some( emplace_as<T>, Args&&...args ){
    emplace<T>(std::forward<Args>(args)...);
  }
  template<class T,class=std::enable_if_t<can_store<std::decay_t<T>>{}>>
  some& operator=(T&&t){
    emplace<std::decay_t<T>>(std::forward<T>(t));
    return *this;
  }

  template<size_t x, size_t a>
  bool load_from( some<x,a> const& o ) {
    if ((void*)&o==this) return true;
    if (!can_fit(o)) return false;
    clear();
    if (o.meta) {
      o.meta->copy( &data, &o.data );
      meta=o.meta;
    }
    return true;
  }
  template<size_t x, size_t a>
  bool load_from( some<x,a> && o ) {
    if ((void*)&o==this) return true;
    if (!can_fit(o)) return false;
    clear();
    if (o.meta) {
      o.meta->move( &data, &o.data );
      meta=o.meta;
      o.clear();
    }
    return true;
  }
  ~some() { clear(); }
};

template<class T, class...Ts>
using some_that_fits = some< (std::max)({sizeof(T),sizeof(Ts)...}), (std::max)({alignof(T),alignof(Ts)...}) >;

基本上，该meta对象是手动实现的虚拟函数表。它减少了给定一个指针的内存开销some（在其存储缓冲区之上）。

活生生的例子

正如上面所证明的，这是相当可行的。

请注意，即使多次调用，也会返回指向相同类型的create相同指针。metaT

我在上面的测试中使用了大约一半的代码路径。其他人可能有错误。

some_that_fits允许您传递一组类型，并返回some适合这些类型的类型。

除了由所述存储类型对存储类型进行操作生成的异常之外，不会引发任何异常。如果可能，我会在编译时进行测试以确保类型适合。

我是否可以通过在数据中的偏移量处启动它们来添加对更大对齐、小型存储类型的支持？