Início / coding / Perguntas / 78713559
Accepted
Gene
Asked: 2024-07-06 08:03:45 +0800 CST

convertendo tupla em problemas variantes

  • 772

Preciso acessar um valor std::tuplepor índice em tempo de execução. Para isso escrevi uma função que retorna a std::variantcom os mesmos tipos inicializados para o índice especificado. A implementação envolve instanciações de modelos recursivos:

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);
}

Estou usando compiladores c++23. O problema é que apenas o gcc compila sem erros. Os compiladores clang e MSVC entram em loop infinito de instanciação. Isso é um bug nos compiladores? Como posso corrigir esse código que ele compila nos três compiladores?

Aqui está a demonstração do Compiler Explorer

c++

4 respostas

  1. Como você está chamando o lambda recursivamente, isso só é possível com um parâmetro de objeto explícito do C++ 23. Isso deve funcionar:

    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);
}

    Demonstração

    • 2
  2. Best Answer

    Funciona se você usar

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

    em vez de. Não há razão para get_nser um lambda.

    • 1

  3. E esta é outra solução possível aceita por todo compilador. A vantagem é que a função lambda é local tuple_to_variant, portanto não cria nenhum nome no escopo externo.

    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>{});
}

    Demonstração do Explorador de Código

    • 0

  4. Uma implementação não recursiva com tipos detalhados seria:

    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;

    Eu gosto de colocar o argumento ativo/operacional/de seleção ( i) primeiro e o argumento passivo ( t) por último.

    • 0

relate perguntas