Como obter um intervalo para fazer loop em contêineres em variantes

Já que você deve confiar em variant::visit, a questão é como fornecer cada item iterado sem ter que processá-lo por meio de algum lambda.

Desde c++20, coroutines podem ser úteis no seu caso de uso: você normalmente usa std::visite de acordo com os tipos de variantes, você chama co_yieldpara que cada item seja iterado. Uma possível implementação de um dedicated mygeneratorno seu caso seria:

using sometype = int;

// We define our variant type.
using VariantSet = std::variant<
    std::set<sometype>,
    std::vector<sometype>,
    sometype
>;

auto mygenerator (VariantSet& v)
{
    // Each visit-lambda has to explicit its return type.
    // Note that `std::generator` is available since `c++23`.
    using result_t = std::generator<sometype>;

    // for 'overloaded', see https://en.cppreference.com/w/cpp/utility/variant/visit2
    return std::visit (overloaded {
        [](std::set<sometype>    const& arg) -> result_t { for (auto const& x : arg)  { co_yield x; } },
        [](std::vector<sometype> const& arg) -> result_t { for (auto const& x : arg)  { co_yield x; } },
        [](sometype              const& arg) -> result_t { co_yield arg; }
    }, v);
}

Você pode usá-lo com

int main ()
{
    std::set   <sometype> x = {2,4,6,8,10};
    std::vector<sometype> y = {1,3,5,7};
    sometype              z = 42;

    VariantSet v;

    v = x;    for (auto const& i : mygenerator(v)) {  std::cout << i << " ";  }  std::cout << "\n";
    v = y;    for (auto const& i : mygenerator(v)) {  std::cout << i << " ";  }  std::cout << "\n";
    v = z;    for (auto const& i : mygenerator(v)) {  std::cout << i << " ";  }  std::cout << "\n";
}

Demonstração

Acho que você poderia canalizar um gerador desses com alguns std::views.

Observe, entretanto, que usar corrotinas dessa maneira pode incorrer em alguma sobrecarga (veja isto e isto ).

Eu estava brincando muito com isso, e até agora tenho uma resposta incompleta, mas alguns assistentes de modelo c++ melhores podem me ajudar. O código atual deve funcionar para contêineres std . Ele ainda precisa de trabalho para permitir corretamente coisas das quais eu possa obter um intervalo , mas isso me ajuda a avançar com a sintaxe desejada.

//This structure will take a variant that can contains containers with the same
//value_type (ints, size_t, floats, whatever). It will create a "variant iterator"
//using the variadic template and the iterator_t helper.

template <typename... ContainerTypes>
struct IterableVariantWrapper {

    //This is the part that i have to figure out yet. If the contained type
    //is NOT a container, but i can obtain a range from it, i'd like to 
    //still allow it, but haven't found the way yet.
    using VariantIter = std::variant<const_iterator_t<ContainerTypes>...>;

    //Original variant we want to iterate over.
    const std::variant<ContainerTypes...>& iterable;

    //The iterator
    struct iterator {
        VariantIter iter;

        bool operator!=(
            const iterator& other) const
        {
            return iter != other.iter;
        }
        iterator operator++()
        {
            auto advanceIter = [](auto& v) -> void { ++v; };
            std::visit(advanceIter, iter);
            return *this;
        }
        auto operator*() const
        {
            auto returnElem = [](const auto& v) { return *v; };
            return std::visit(returnElem, iter);
        }
    };

    

    auto begin()
    {
        auto getBegin = [](const auto& v) -> VariantIter {
            VariantIter iter = v.begin();
            return iter;
        };
        return iterator { std::visit(getBegin, iterable) };
    }
    auto end()
    {
        auto getEnd = [](const auto& v) -> VariantIter { return v.end(); };
        return iterator { std::visit(getEnd, iterable) };
    }
};



//Calling this with a variant that contains a container where the contained
//type is the same will build the IterableVariantWrapper structure and provide
//a range-like object
template <typename... ContainerTypes>
auto getVariantRange(
    const std::variant<ContainerTypes...>& variant)
{
    return IterableVariantWrapper { variant };
}

Eu estava pensando que talvez ter uma função/struct onde eu pudesse perguntar o tipo da view que eu posso obter dos objetos iterados pode ser uma maneira de fazer, mas eu não consegui entender a sintaxe. Por exemplo, ter uma função para cada tipo que está contido na variante onde a função retorna o mesmo objeto se ele já for um intervalo, ou uma view derivada dele, e então o iterador da variante deduz os tipos do tipo de retorno dessa função.

Pelo que vejo, ainda preciso descobrir como dar suporte a intervalos reais onde o sentinela é de um tipo diferente, o que acho que será o próximo passo depois do parágrafo anterior.

Um link para um exemplo funcional usando isto: https://godbolt.org/z/qhrbP1se6

Qualquer comentário para melhorias futuras será muito apreciado.

ATUALIZAÇÃO : Fiz isso funcionar como eu queria, usando um "conversor" intermediário que cria intervalos de qualquer representação que eu tenha armazenado na variante e é compatível com std::ranges. Não atualizei o código aqui, pois ele adiciona mais coisas de modelo que não tenho certeza se são relevantes para a maioria das pessoas que encontrarão esse problema. Você pode ver o exemplo funcional aqui: https://godbolt.org/z/68q13GKdq .