主页 / coding / 问题 / 78713559
Accepted
Gene
Asked: 2024-07-06 08:03:45 +0800 CST

将元组转换为变体问题

  • 772

我需要std::tuple在运行时通过索引访问 中的值。为此，我编写了一个函数，该函数返回std::variant具有针对指定索引初始化的相同类型的值。实现涉及递归模板实例化：

template<std::size_t N>
constexpr auto get_n = [](/*tuple-like*/auto&& t, std::size_t index)
{
    using variant_type = decltype(std::apply([](auto&&... v){
        return std::variant<std::monostate, std::remove_cvref_t<decltype(v)>...>{};
    }, t));

    constexpr auto size = std::tuple_size_v<std::remove_cvref_t<decltype(t)>>;

    if constexpr(N > size)
        return variant_type{};
    else 
    {
        if(N == index + 1)
            return variant_type(std::in_place_index<N>, std::get<N - 1>(t));
        else
            return get_n<N + 1>(t, index);
    }
};

constexpr auto tuple_to_variant(/*tuple-like*/auto&& t, std::size_t index)
{
    return get_n<1>(std::forward<decltype(t)>(t), index);
}

我使用的是 c++23 编译器。问题是只有 gcc 编译时没有错误。clang 和 MSVC 编译器进入无限实例化循环。这是编译器中的错误吗？我该如何修复这三个编译器中都编译的代码？

这是 Compiler Explorer演示

c++

4 个回答

  1. 由于您正在递归调用 lambda，因此这只能通过 C++23 显式对象参数来实现。这应该有效：

    constexpr auto get_n = []<std::size_t N>
  (this auto self, /*tuple-like*/auto&& t, std::size_t index)
{
    using variant_type = decltype(std::apply([](auto&&... v){
        return std::variant<std::monostate, std::remove_cvref_t<decltype(v)>...>{};
    }, t));

    constexpr auto size = std::tuple_size_v<std::remove_cvref_t<decltype(t)>>;

    if constexpr(N > size)
        return variant_type{};
    else 
    {
        if(N == index + 1)
            return variant_type(std::in_place_index<N>, std::get<N - 1>(t));
        else
            return self.template operator()<N + 1>(t, index);
    }
};

constexpr auto tuple_to_variant(/*tuple-like*/auto&& t, std::size_t index)
{
    return get_n.operator()<1>(std::forward<decltype(t)>(t), index);
}

    演示

    • 2
  2. Best Answer

    如果你使用

    template<std::size_t N>
constexpr auto get_n(/*tuple-like*/auto&& t, std::size_t index)

    相反。没有理由get_n成为 lambda。

    • 1

  3. 这是每个编译器都接受的另一种可能的解决方案。优点是 lambda 函数在内部是本地的tuple_to_variant，因此它不会在外部作用域中创建任何名称。

    inline auto tuple_to_variant(auto&& t, std::size_t index)
{
    constexpr auto get_n = []<auto N>(this auto&& self, auto&& t, std::size_t index, std::index_sequence<N>)
    {
        using variant_type = decltype(std::apply([](auto&&... v){
            return std::variant<std::monostate, std::remove_cvref_t<decltype(v)>...>{};
        }, t));

        constexpr auto size = std::tuple_size_v<std::remove_cvref_t<decltype(t)>>;

        if constexpr(N > size)
            return variant_type{};
        else 
        {
            if(N == index + 1)
                return variant_type(std::in_place_index<N>, std::get<N - 1>(t));
            else
                return self(t, index, std::index_sequence<N + 1>{});
        }
    };

    return get_n(std::forward<decltype(t)>(t), index, std::index_sequence<1>{});
}

    代码资源管理器演示

    • 0

  4. 具有详细类型的非递归实现将是：

    constexpr auto tuple_to_variant(std::size_t i, auto && t)
{
    using ref_t = decltype(t);
    using tuple = std::remove_cvref_t<ref_t>;
    constexpr std::tuple_size<tuple> size;
    return [&t]<std::size_t ... j>
    (std::index_sequence<j ...>, auto i) {
          using variant = std::variant
                        < std::monostate
                        , std::remove_cvref_t
                        < std::tuple_element_t<j, tuple> > ...>;
          constexpr std::array dispatch {
              +[](ref_t&) { return variant{}; },
              +[](ref_t& lvalue_) {
              return variant 
                   { std::in_place_index<1 + j>
                   , get<j>(static_cast<ref_t>(lvalue_)) };
              }...
          };// dispatch;
          return dispatch[i](t);
    }(make_index_sequence<size()>{}
    , i >= size() ? 0 : 1 + i);
};// tuple_to_variant;

    我喜欢把主动/操作/选择论点（i）放在第一位，把被动论点（t）放在最后。

    • 0

相关问题