在实现类似std::variant的类时存储类型标记的问题

Question

我的目标是编写std::variant，可能不是完全成熟，但至少具有完全工作的构造函数/析构函数对和std::get<>()函数。

我尝试使用char数组保留内存。其大小由find_biggest_size<>()函数求出的最大类型决定。构造函数使用静态断言，因为它执行检查类型是否在指定类型列表中。现在，构造函数和原地构造函数可以工作。

template <typename ... alternatives>
class variant
{
    char object[find_biggest_size<alternatives...>::value];
public:
    template <typename T>
    variant(T&& other)
    {
        static_assert(is_present<T, alternatives...>::value, "type is not in range");
        new ((T*)&object[0]) T(std::forward<T>(other));
    }
    template <typename T, typename ... ArgTypes>
    variant(in_place_t<T>, ArgTypes&& ... args)
    {
        static_assert(is_present<T, alternatives...>::value, "type is not in range");
        new ((T*)&object[0]) T(std::forward<ArgTypes>(args)...);
    }
    ~variant()
    {
        // what to do here?
    }
};

然后我偶然发现了一个问题。我不知道对象死亡时执行什么析构函数。最重要的是，访问底层对象是不可能的，因为我不能专门化std::get<>()以获得正确的类型。

我的问题是:如何存储对象创建后的类型?这是正确的方法吗?如果没有，我应该用什么?

编辑:

我试着应用注释。问题是当前活动类型的索引不能是constexpr，因此我不能从类型列表中提取所需的类型并调用适当的析构函数。

~variant()
{
    using T = typename extract<index, alternatives...>::type;
    (T*)&object[0]->~T();
}

编辑:

我已经做了一个基线实现。它可以工作，但有很多缺失的功能。你可以在这里找到。我很高兴收到评论，但请先阅读我如何写一个好答案?

Answer 1

如何开始:

#include <iostream>
#include <utility>
#include <array>
template<class...Types>
struct variant
{
    variant() {}
    ~variant()
    {
        if (type_ >= 0)
        {
            invoke_destructor(type_, reinterpret_cast<char*>(std::addressof(storage_)));
        }
    }
    template<class T> static void invoke_destructor_impl(char* object)
    {
        auto pt = reinterpret_cast<T*>(object);
        pt->~T();
    }
    static void invoke_destructor(int type, char* address)
    {
        static const std::array<void (*)(char*), sizeof...(Types)> destructors
        {
            std::addressof(invoke_destructor_impl<Types>)...
        };
        destructors[type](address);
    }
    std::aligned_union_t<0, Types...> storage_;
    int type_ = -1;
};
int main()
{
    variant<int, std::string> v;
}

Answer 2

首先，您需要知道哪个对象当前在变体中。如果您想从中获取当前不在其中的类型，则必须抛出异常。

对于存储，我使用了一个联合(就像我在这里做的那样，使它成为constexpr);你不能使用放置新操作符作为constexpr，所以我认为联合是唯一实际的方法(这意味着我唯一想到的)。请注意:您仍然需要显式调用析构函数。这就产生了一个奇怪的解决方法，因为在constexpr中使用的类型必须是可破坏的。

现在:你可以实现一个类似于find_biggest_size的类，它将int类型作为模板形参。例如，类似这样的内容(不完整的示例):

template<int idx, typename ...Args>
struct get_type;
template<int idx, typename First, typename ...Rest>
struct get_type<idx, First, Rest...>
{
    using type = typename get_type<idx-1, Rest>::type;    
};
template<typename First, typename ...Rest>
struct get_type<0, First, Rest...>
{
    using type = First;
};
//plus specialization without Rest

然后你可以实现get函数:

template<int i, typename ...Args>
auto get(variant<Args...> & v) -> typename get_type<i, Args...>::type
{ /* however you do that */ }