Início / coding / Perguntas / 79173087
Accepted
Bernard
Asked: 2024-11-09 23:34:41 +0800 CST

Obter um índice de tempo de compilação para um std::variant ao visitá-lo? [duplicado]

  • 772

Tenho vários std::varianttipos possivelmente repetidos e gostaria de incrementar o índice ativo da variante.

Aqui está um exemplo que demonstra o que eu gostaria de fazer:

template <typename... Ts>
bool update_variant(std::variant<Ts>& v, std::tuple<work_generator<Ts>>& gen) {
    return visit_with_index([&]<size_t Index /* the active index */>(auto& e) {
        if (e.done()) {
            // we are done with e
            constexpr size_t next_index = Index + 1;
            if constexpr (next_index == sizeof...(Ts)) {
                // no more other work to do
                return false;
            } else {
                // still have other work to do so we move on to the next variant alternative
                v.emplace(
                        std::in_place_index_t<next_index>{},
                        std::get<next_index>(gen).create_worker()
                    );
                return true;
            }
        } else {
            // do some work on e, so e gets closer to the done state
            e.do_some_work();
            return true;
        }
    }, v);
}

Para implementar isso, parece que preciso de algo semelhante ao visit_with_indexacima, que me forneça o índice atual como um valor de tempo de compilação.

Além de escrever minha própria versão do visit_with_indexacima, que efetivamente é escrever minha própria versão de std::visit, há alguma maneira mais simples de conseguir o que quero sem realizar mais de uma pesquisa por índice?

c++

2 respostas

  1. Best Answer

    Eu usaria visitno índice "diretamente" .

    Primeiro

    template <typename... Ts>
auto get_index_variant(const std::variant<Ts...>& v)
{
    return [&]<std::size_t...Is>(std::index_sequence<Is...>){
        using Ret = std::variant<std::integral_constant<std::size_t, Is>...>;
        std::array<Ret, sizeof...(Is)> a = {{Ret{std::integral_constant<std::size_t, Is>{}}...}};
        return a[v.index()];
    }(std::make_index_sequence<sizeof...(Ts)>());
}

    Então

    std::visit([&](auto index){ // index() is constexpr
    // ...
    }, get_index_variant(v));

    Demonstração

    • 3

  2. Se tudo o que você se importa é uma única visita, então o Boost.Mp11 mp_with_indexjá é o que você quer:

    template <typename... Ts>
bool update_variant(std::variant<Ts...>& v, std::tuple<work_generator<Ts>>& gen) {
    return mp_with_index<sizeof...(Ts)>(v.index(), [&](auto I){
        // ... 
    });
}

    Aqui Iestá um integral_constant<size_t, V>para alguns V, para que possa ser usado diretamente como std::get<I>(x).

    Internamente, mp_with_index<N>(i, f)é basicamente um switch (i)conjunto de valores de 0para N - 1.

    • 1

relate perguntas