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

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

最佳答案

这是一个基本的 some .

T copy/assign/move/etc 可以根据 emplace 来实现. SFINAE 使用 can_store<T>可以确保只键入 some实际上可以存储可分配给它，避免不必要的异常。

目前，从 some 移动销毁它的内容而不是仅仅从它那里移动。还有一个 some可以为空(它们是“可为空的”)。

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

some_meta是手动虚函数表。每种类型一个 T你存储在 some任何大小。它存储类型删除的操作 T那some想要使用(在这种情况下，复制移动和销毁)，加上一些关于类型的数据(大小、对齐和类型标识)。它可以通过比较和序列化等额外操作来扩充。对于二进制操作，必须考虑处理“无匹配类型”的逻辑。对于序列化之类的东西，我会让它调用自由函数 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 object 基本上是一个手动实现的虚函数表。它减少了给定 some 的内存开销指向一个指针(在其存储缓冲区之上)。

live example

如上所示，它非常可行。

请注意 create返回指向相同 meta 的指针对于同类型T ，即使调用了不止一次。

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

some_that_fits让你传递一组类型，它返回一个 some适合这些类型的类型。

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

我可以通过在我的数据中以偏移量开始它们来添加对更好对齐、小型存储类型的支持吗？

关于c++ - 为什么在增强或标准中没有 "variant"？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/27173377/