Função variádica para percorrer o produto cartesiano de vários intervalos

Com C++23 isso é muito mais fácil graças a std::views::cartesian_product():

parafuso divino

template<class Fn, class... Spans>
void loop(Fn&& fn, Spans... spans) {
    for(auto tuple : std::views::cartesian_product(spans...)) {
        std::apply(std::forward<Fn>(fn), tuple);
    }
}

Se você estiver limitado ao C++20, terá que fazer o produto cartesiano sozinho - por exemplo, usando recursão e vinculando o valor atual de cada intervalo à função:

parafuso divino

template<class Fn, class FirstSpan, class... OtherSpans>
requires std::ranges::range<FirstSpan> && (std::ranges::range<OtherSpans> && ...)
void loop(Fn&& fn, FirstSpan first, OtherSpans... otherSpans) {
    for(auto& el: first) {
        if constexpr(sizeof...(OtherSpans) > 0) {
            loop(std::bind_front(fn, el), otherSpans...);
        } else {
            fn(el);
        }
    }
}

Nenhuma implementação de biblioteca padrão: (conforme solicitado nos comentários)
godbolt

template<class Fn, class Span, class... OtherSpans>
void loop(Fn&& fn, Span firstSpan, OtherSpans... otherSpans) {
    if constexpr(sizeof...(OtherSpans) > 0) {
        for(auto& el : firstSpan) {
            loop(
                [&](auto&... values) {
                    fn(el, values...);
                },
                otherSpans...
            );
        }
    } else {
        for(auto& el : firstSpan) {
           fn(el);
        }
    }
}

Você pode combinar ranges::for_eachcom C++23 views::cartesian_productcomo:

template <typename Func, typename ...Spans>
void loop(Func func, Spans &&...spans) {
  std::ranges::for_each(
    std::views::cartesian_product(spans...),
    [&](auto&& elem) { std::apply(func, elem); }
  );
}

Aqui está uma simplificação de uma resposta deste post que permite gerar em tempo de compilação o produto cartesiano de várias matrizes.

#include <tuple>
#include <array>
#include <type_traits>
#include <iostream>

////////////////////////////////////////////////////////////////////////////////
template<typename FCT, typename...ARRAYS>
constexpr auto cartesian_product_loop (FCT fct, ARRAYS...arrays)
{
    // we define the number of entries
    constexpr std::size_t N = (1 * ... * arrays.size());

    // we compute the dimensions of the successive parts of the tensor
    std::array<std::size_t,sizeof...(arrays)> dims { arrays.size()... };
    for (std::size_t i=1; i<dims.size(); ++i)  { dims[i] *= dims[i-1]; }
        
    // we iterate each possible entry
    for (std::size_t i=0; i<N; ++i)
    {
        [&]<std::size_t... Is>(std::index_sequence<Is...>) 
        {
           // we demultiplex the current index for each array from the global index 'i'
           auto idx = std::make_tuple ( ( (i*std::get<Is>(dims)) / N) % arrays.size() ...);

           // we call the function with the current entry.
           fct (arrays[std::get<Is>(idx)]...);
            
        }(std::make_index_sequence<sizeof...(arrays)>{});
    }
}

////////////////////////////////////////////////////////////////////////////////

int main() 
{
    std::array<int,   3> a1  {1, 2, 3}; 
    std::array<char,  2> a2  {'a','b'}; 
    std::array<double,4> a3  {2.0, 4.0, 6.0, 8.0}; 

    auto fct = [] (auto...args)
    {
        ((std::cout << args << ' '), ...) << "\n";
    };
    
    cartesian_product_loop (fct, a1,a2,a3);
} 

Demonstração

A ideia principal é iterar um inteiro ide 0 a N-1 (com N o número de entradas possíveis do produto cartesiano) e desse inteiro 'global', recupera-se como uma tupla o índice idxde cada array que faz a entrada atual. Então, é preciso apenas chamar a função fornecida fctcom argumentos sendo uma expressão fold nesse índice idx.

Ele usa principalmente expressões fold e std::make_index_sequence/ std::index_sequence. Ele também supõe que os arrays fornecidos suportam métodos operator[]e size.

Funciona com c++17 e superiores.

Aqui está uma alternativa que usa um array para manter o controle dos índices para cada um dos spans. O array de índices é declarado para ter nSpans+1elementos onde o primeiro elemento serve como um sentinela. O array spanSizesé declarado para ter o mesmo tamanho e também ter um sentinela. A variável carryIndexmantém o controle de qual índice deve ser incrementado. A palavra "carry" aqui se refere ao fato de que os índices são incrementados de uma maneira similar a carries em adições.

template<class Fn, class... Spans>
void loop(Fn&& fn, Spans... spans) {
    constexpr std::size_t nSpans = sizeof...(spans);
    // Array containing the sizes of each span, with a sentinel in front
    std::size_t spanSizes[]{0, spans.size()...};
    // Array containing the loop indexes, also with a sentinel in front
    std::size_t indexes[nSpans+1]{};
    // Points to the index that should be incremented, after considering carries from less significant indexes
    std::size_t carryIndex = nSpans;
    // While the sentinel (most significant index) is not reached
    while(indexes[0] == 0){
        // Call `fn` with perfect forwarding, passing in elements picked from each span according to the corresponding index.
        // The +1 accounts for the sentinel.
        [&]<std::size_t... Is>(std::index_sequence<Is...>){
            std::forward<Fn>(fn)(spans[indexes[Is+1]]...);
        }(std::make_index_sequence<nSpans>());
        // Increment the current index.
        ++indexes[nSpans];
        // Loop while there's need to carry to a more significant index
        while(indexes[carryIndex] == spanSizes[carryIndex]){
            // Reset the index.
            indexes[carryIndex] = 0;
            // Update `carryIndex` to point to the next more significant index and increment it.
            ++indexes[--carryIndex];

            // The next increment should start over from the least significant index.
            if(indexes[carryIndex] != spanSizes[carryIndex]){
                carryIndex = nSpans;
            }
        }
    }
}

Demonstração: https://godbolt.org/z/ejzhe7e5G ( main()Foi retirado da demonstração na resposta de @Turtlefight )