默认从索引构造 std::variant

Question

当索引仅在运行时已知时，从所需类型的索引默认构造 std::variant 的最简单方法是什么？换句话说，我想写：

const auto indx = std::variant<types...>{someobject}.index();
//...somewhere later, indx having been passed around...
std::variant<types...> var = variant_from_index(indx);
///var is now set to contain a default constructed someobject

请注意，indx不能进行 constexpr，因此std::in_place_index在此处不起作用。

这里的问题当然是，由于不知道types...在编译时调用哪个构造函数，所以基本上必须在编译时构建所有可能的构造函数（或者可能是默认构造的变体）的表，然后访问在运行时。一些模板魔术显然在这里就位，但最干净的方法是什么？

我尝试了以下（在 coliru 上），但索引序列似乎出错了（最后的打印给出了2 0 0），我很困惑为什么：

编辑：它的工作方式如下固定，我的 constexpr 数组初始化错误。所以现在的问题是，有没有更简洁的方法来做到这一点？

#include <variant>
#include <iostream>

using var_t = std::variant<int, float, const char *>;

//For debug
template<class ...types>
struct WhichType;

template<class T, class U>
struct default_variants;
template<class...Params, std::size_t... I>
struct default_variants<std::variant<Params...>, std::index_sequence<I...>> {
    using variant_t = std::variant<Params...>;
    //Uncomment to see the index sequence
    //WhichType<std::index_sequence<I...>> idx{};
    constexpr static variant_t variants[sizeof...(Params)]{variant_t{std::in_place_index<I>}...};
    constexpr static std::size_t indices[sizeof...(Params)]{I...};
};
template<class T>
struct default_variants_builder;
template<class...Params>
struct default_variants_builder<std::variant<Params...>> {
    using indices = std::make_index_sequence<sizeof...(Params)>;
    using type = default_variants<std::variant<Params...>, indices>;
};


int main() {
    using builder_t = typename default_variants_builder<var_t>::type;
    var_t floatvar{1.2f};
    var_t variant2 = builder_t::variants[floatvar.index()];
    std::cout << "Contained " << floatvar.index() << "; Now contains " << variant2.index() << "\n";
}

Answer 1

使用Boost.Mp11这基本上是一个单行（一如既往）：

template <typename V>
auto variant_from_index(size_t index) -> V
{
    return mp_with_index<mp_size<V>>(index,
        [](auto I){ return V(std::in_place_index<I>); });
}

您对问题的描述是准确的 - 您需要一种将运行时索引转换为编译时索引的方法。mp_with_index为你做这件事 - 你给它运行时索引和最大编译时索引（mp_size<V>在这里，它会给出与std::variant_size_v<V>你喜欢的相同的值），它会调用你提供的正确常量的函数（这里I有类型integral_constant<size_t, index>，除非index是一个常量表达式）。

Answer 2

这个怎么样？

template <class Variant, std::size_t I = 0>
Variant variant_from_index(std::size_t index) {
    if constexpr(I >= std::variant_size_v<Variant>)
        throw std::runtime_error{"Variant index " + std::to_string(I + index) + " out of bounds"};
    else
        return index == 0
            ? Variant{std::in_place_index<I>}
            : variant_from_index<Variant, I + 1>(index - 1);
}

在 Wandbox 上实时观看