Question

any优于variant的一个优点是，它不需要指定它可能包含的所有类型。我注意到，随着variant可能包含的类型数量增加，人们往往会在某个时候切换到any，因为他们根本不再跟踪所有类型。我认为any和variant之间的混合是可能的。可以在placeholder中存储new的“any”（通过展示位置aligned_storage），其大小在constexpr函数或模板元函数中计算，来自可能最终存储的最大类型的样本。另一方面，用户不需要指定any可能包含的所有类型。如果用户试图在那里存储大于any的内容，aligned_storage也可以随时抛出。

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

Answer 1

这是一个基本的some。

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

目前，从some移动会破坏其内容，而不是仅仅移动它。而some可以为空（它们是＆＃34;可以无效＆＃34;）。

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

some_meta是一个手动虚拟功能表。每种类型T存在一个，您存储在任意大小的some中。它将类型擦除操作存储在T想要使用的类型some上（在这种情况下，复制移动和销毁），以及有关类型（大小，对齐和类型标识）的一些数据。它可以通过比较和序列化等附加操作进行扩充。对于二进制操作，处理＆＃34;没有匹配类型的逻辑＆＃34;必须考虑。对于序列化等内容，我可以在serialize上调用自由函数deserialize和T。在这两种情况下，我们对some可以存储的内容施加了额外的要求（您可以通过一些工作处理＆＃34;可能序列化＆＃34;，但这会变得混乱）。

您甚至可以想象一个系统，您可以在其中存储一组操作以对数据执行（二进制和一元），并传递捆绑在传递给某些类型的类型中的所述操作。在这一点上，我们正在接近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的内存开销减少到一个指针（在其存储缓冲区之上）。

live example

如上所述，它非常可行。

请注意，即使多次调用，create也会为同一类型meta返回指向同一T的指针。

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

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

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

我可以通过在偏移到我的数据中启动它们来添加对更大对齐，小存储类型的支持吗？

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

1 个答案: