c++ - 元组的运行时索引

Question

假设我有一个变量 constructors ，它是以可变参数泛型 lambda 表示的构造函数元组。

// types for constructors 
using type_tuple = std::tuple<ClassA, ClassB, ClassC>;

// Get a tuple of constructors(variadic generic lambda) of types in type_tuple
auto constructors = execute_all_t<type_tuple>(get_construct());

// For definitions of execute_all_t and get_construct, see link at the bottom.

我可以实例化一个对象:

// Create an object using the constructors, where 0 is index of ClassA in the tuple.
ClassA a = std::get<0>(constructors)(/*arguments for any constructor of ClassA*/);

是否可以在运行时使用 magic_get 对类型进行索引？像下面？

auto obj = magic_get(constructors, 0)(/*arguments for any constructor of ClassA*/);

// Maybe obj can be a std::variant<ClassA, ClassB, ClassC>, which contains object of ClassA?

编辑 : 理想情况下 obj应该是 ClassA 的一个实例.如果不可能，我可以接受 obj成为 std::variant<ClassA, ClassB, ClassC> .

请查看最小的可重现示例: Try it online!

一个类似的问题: C++11 way to index tuple at runtime without using switch .

Answer 1

你可能会让你的运行时返回 std::variant ， 就像是:

template <typename ... Ts, std::size_t ... Is>
std::variant<Ts...> get_impl(std::size_t index,
                             std::index_sequence<Is...>,
                             const std::tuple<Ts...>& t)
{
    using getter_type = std::variant<Ts...> (*)(const std::tuple<Ts...>&);
    getter_type funcs[] = {+[](const std::tuple<Ts...>& tuple)
                            -> std::variant<Ts...>
                            { return std::get<Is>(tuple); } ...};

    return funcs[index](t);
}

template <typename ... Ts>
std::variant<Ts...> get(std::size_t index, const std::tuple<Ts...>& t)
{
    return get_impl(index, std::index_sequence_for<Ts...>(), t);
}

那么你可能会 std::visit你的变种做你想做的事。

Demo

或对于您的“工厂”示例:

int argA1 = /*..*/;
std::string argA2 = /*..*/;
int argB1 = /*..*/;
// ...

auto obj = std::visit(overloaded{
                [&](const A&) -> std::variant<A, B, C> { return A(argA1, argA2); },
                [&](const B&) -> std::variant<A, B, C> { return B(argB1); },
                [&](const C&) -> std::variant<A, B, C> { return C(); },
            }, get(i, t))