Chamada de função de várias listas de modelos variáveis

Não sei se esta é a maneira mais elegante, mas pelo menos está funcionando:

#include <cstdint>
#include <iostream>

template<typename U, typename V, typename W>
void MyFunc() {
    std::cout << typeid(U).name() << ", " << typeid(V).name() << ", " << typeid(W).name() << std::endl;
}

template<typename... Types>
struct TypeContainer {
};

template<typename U, typename V, typename Ws>
struct for_loops_1;

template<typename U, typename V, typename... Ws>
struct for_loops_1<U, V, TypeContainer<Ws...> > {
    static void call() {
        (MyFunc<U, V, Ws>(), ...);
    }
};

template<typename U, typename Vs, typename Ws>
struct for_loops_2;

template<typename U, typename... Vs, typename Ws>
struct for_loops_2<U, TypeContainer<Vs...>, Ws> {
    static void call() {
        (for_loops_1<U, Vs, Ws>::call(), ...);
    }
};

template<typename Us, typename Vs, typename Ws>
struct for_loops_3;

template<typename... Us, typename V, typename W>
struct for_loops_3<TypeContainer<Us...>, V, W> {
    static void call() {
        (for_loops_2<Us, V, W>::call(), ...);
    }
};

int main() {
    for_loops_3<
        TypeContainer<float, double>,
        TypeContainer<uint64_t, std::string_view>,
        TypeContainer<int, short, long>
    >::call();
}

Minha versão tem apenas 3 listas de argumentos variáveis, mas deve ser fácil estender a ideia para qualquer número fixo de listas de tipos.

A ideia central é obter múltiplas listas de argumentos variádicos capturando-os em uma struct que por si só tem argumentos de template variádicos. Isso permite passar múltiplas listas em uma struct/função.

E então usei structs em vez de funções para fazer uso da especialização parcial, que permite que você acesse os argumentos variáveis ​​que estão compactados no TypeContainer.

O que você precisa é fazer o produto cartesiano dos tipos, o que pode ser feito facilmente usando boost::mp11:

#include <boost/mp11.hpp>

using namespace boost::mp11;

using Ts = mp_list<char, int, long long>;
using Us = mp_list<float, double>;
using Vs = mp_list<std::uint64_t, std::string_view>;
using Ws = mp_list<int, MyEnum1, MyEnum2, MyEnum3>;
using Product = mp_product<mp_list, Ts, Us, Vs, Ws>;

mp_for_each<Product>([&]<class... Ts>(mp_list<Ts...>) {
  MyFunc<Ts...>();
});

Aqui está um método que funciona para um número arbitrário de listas de tipos usando apenas recursos do C++20 e bibliotecas padrão. As listas de tipos são expressas com um aninhado std::tuple.

#include <cstdint>
#include <numeric>
#include <tuple>
#include <array>

template <typename Tuple, std::size_t... Sizes>
constexpr auto loopForTypesHelper()
{
    constexpr std::array sizes{Sizes...};
    constexpr auto cumprod = [&](){
        std::array<std::size_t, sizes.size()+1> result;
        std::partial_sum(sizes.rbegin(), sizes.rend(), result.rbegin()+1, std::multiplies{});
        result[sizes.size()] = 1;
        return result;
    }();
    
    auto expandForIdx = [&]<auto Idx, auto... ArrayIdx>(std::index_sequence<ArrayIdx...>){
        myFunc<
            std::tuple_element_t<Idx/cumprod[ArrayIdx + 1]%sizes[ArrayIdx],
            std::tuple_element_t<ArrayIdx, Tuple>>...
        >();
    };

    [&]<auto... Idx>(std::index_sequence<Idx...>){
        ((expandForIdx.template operator()<Idx>(std::make_index_sequence<sizeof...(Sizes)>{})), ...);
    }(std::make_index_sequence<cumprod[0]>{});
}

template <typename Tuple>
constexpr auto loopForTypes(){
    return [&]<auto... Is>(std::index_sequence<Is...>){
        return loopForTypesHelper<Tuple, std::tuple_size_v<std::tuple_element_t<Is, Tuple>>...>();
    }(std::make_index_sequence<std::tuple_size_v<Tuple>>{});
}

int main(){
    using TypeLists =
        std::tuple<
            std::tuple<char, int, long long>,
            std::tuple<float, double>,
            std::tuple<std::uint64_t, std::string_view>,
            std::tuple<int, MyEnum1, MyEnum2, MyEnum3>
        >;
    loopForTypes<TypeLists>();
}

Em loopForTypesHelper(), o array sizescontém os tamanhos para as listas de tipos para loop. No caso do OP, o array sizescontém os elementos 3, 2, 2, 4.

As próximas linhas usam o algoritmo padrão para obter os produtos acumulativos dos elementos, começando pelos últimos elementos, e armazenam o resultado em um constexpr arraynomeado cumprod. Um elemento extra 1é anexado ao final para facilitar a codificação posterior. No caso do OP, o array cumprodcontém o array 48, 16, 8, 4, 1.

A declaração-chave para expandir os tipos é a seguinte:

myFunc<
    std::tuple_element_t<Idx/cumprod[ArrayIdx + 1]%sizes[ArrayIdx],
    std::tuple_element_t<ArrayIdx, Tuple>>...
>();

Aqui, Idxestá um número que faz um loop de 0 a cumprod[0]-1(veja abaixo), Para cada Idx, a expressão Idx/cumprod[ArrayIdx+1]%sizes[ArrayIdx]indica qual tipo devemos escolher da ArrayIdx-ésima lista de tipos na Idx-ésima iteração. O primeiro (interno) std::tuple_element_tescolhe o tipo da lista de tipos correspondente enquanto o segundo (externo) std::tuple_element_tescolhe uma lista de tipos da lista de listas de tipos. O final ...expande o ArrayIdxpara coletar os tipos escolhidos de cada lista de tipos e passá-los como argumentos de modelo para myFunc.

Depois de definir isso,

    [&]<auto... Idx>(std::index_sequence<Idx...>){
        ((expandForIdx.template operator()<Idx>(std::make_index_sequence<sizeof...(Sizes)>{})), ...);
    }(std::make_index_sequence<cumprod[0]>{});

usa o std::make_index_sequencepara realmente executar o loop for Idxfrom 0to cumprod[0]-1.

loopForTypesé simplesmente um wrapper loopForTypesHelperque expande os tamanhos de cada lista de tipos como argumentos de modelo.

Isso pode ser aplicado a um número arbitrário de listas de tipos e pode ser reescrito de modo que, em vez de codificar rigidamente, myFuncseja possível passar qualquer functor com um templated operator(). O único limite é que o número total de iterações ( cumprod[0]) é restrito pelos limites máximos de expansão de template definidos pela implementação.

Demonstração: https://godbolt.org/z/dP43hM4qT

Você tem outra possibilidade usando std::views::cartesian_productpara produzir todas as combinações possíveis de índices como um constexprstd::array

    constexpr static std::size_t N = (1*...*std::tuple_size_v<Ts>);

    constexpr static auto indexes = [] ()
    {
        static constexpr auto v = std::views::cartesian_product(
            std::views::iota(0) 
         |  std::views::take(std::tuple_size_v<Ts>) 
         ...
        )
         |  std::views::transform ([](auto tup) { 
                return apply([](auto... n) { return std::array<int, sizeof...(n)>{n...};}, tup); 
            })
        ;

        std::array<std::array<int,sizeof...(Ts)>,N> arr {};
        for (auto [i,t] : v | std::views::enumerate)    { arr[i] = t; }
        return arr;
    }();

Então você pode chamar a função necessária para cada combinação:

    auto operator() () const
    {
        using alltypes = std::tuple<Ts...>;

        auto fct = [&] <std::size_t Cb> () {
            // We call the function for a given combination.
            [&] <std::size_t...Is> (std::index_sequence<Is...>) {
                FCT<std::tuple_element_t<indexes[Cb][Is], std::tuple_element_t<Is,alltypes>>...> {} ();
            } (std::make_index_sequence<sizeof...(Ts)>{});
        };
  
        // We iterate all possible combinations.
        [&] <std::size_t...Cb> (std::index_sequence<Cb...>) {
            (fct.template operator() <Cb>(),...);            
        } (std::make_index_sequence<N>{});       
    }

Você pode reunir tudo isso em uma Executorstruct e usá-la assim:

enum MyEnum1{};
enum MyEnum2{};
enum MyEnum3{};

template <typename A, typename B, typename C, typename D>
struct MyFunc
{
    auto operator() () const 
    {  
        std::cout << "[A] " << typeid(A).name() << " "; 
        std::cout << "[B] " << typeid(B).name() << " "; 
        std::cout << "[C] " << typeid(C).name() << " "; 
        std::cout << "[D] " << typeid(D).name() << "\n"; 
    }
};

int main()
{    
    using T = std::tuple<char,int,long>;
    using U = std::tuple<float,double>;
    using V = std::tuple<uint64_t, std::string_view>;
    using W = std::tuple<int,MyEnum1,MyEnum2,MyEnum3>;

    Executor<MyFunc,T,U,V,W> {} ();
}

Uma demonstração completa aqui .

Atualizar

É possível tornar a solução um pouco mais genérica usando uma  sequencefunção que recebe como entrada uma lista de inteiros e chama um lambda com cada combinação de índices possível cbdo produto cartesiano. Ele também fornece um pacote de inteiros que podem ser usados ​​para expressões de dobra, por exemplo. Se alguém fornece apenas uma dimensão para sequence, então o pacote de inteiros é a única informação fornecida e o lambda tem permissão para retornar algum valor.

A mainfunção se tornaria:

enum MyEnum1{};
enum MyEnum2{};
enum MyEnum3{};

template <typename A, typename B, typename C, typename D>
auto MyFunc ()
{
    std::cout << "[A] " << typeid(A).name() << " ";
    std::cout << "[B] " << typeid(B).name() << " ";
    std::cout << "[C] " << typeid(C).name() << " ";
    std::cout << "[D] " << typeid(D).name() << "\n";
}

int main()
{
    // We define our type lists as tuples.
    using T = std::tuple<char,int,long>;
    using U = std::tuple<float,double>;
    using V = std::tuple<uint64_t, std::string_view>;
    using W = std::tuple<int,MyEnum1,MyEnum2,MyEnum3>;

    // We gather our type lists into a single tuple
    using alltypes = std::tuple<T,U,V,W>;

    constexpr auto nbtypes = std::tuple_size_v<alltypes>;

    // We build an array holding the number of elements in the tuples T,U,V,W
    // In this case, idx represents [0,1,...,nbtypes-1]
    constexpr auto sizes = pack::sequence <nbtypes> ([&] <auto...idx> ()
    {
        return std::array { std::tuple_size_v<std::tuple_element_t<idx,alltypes>>... } ;
    });

    // We iterate all the combinations of the Cartesian product.
    pack::sequence <sizes> ([&] <auto cb, auto...idx> ()
    {
        // 'cb'  represents an array of indexes for a combination among all possible combinations of the Cartesian product
        // 'idx' represents the sequence 0,1,2,...,N-1 that can be used for instance in fold expressions

        // We call our function with a combination of template types.
        MyFunc<std::tuple_element_t<cb[idx], std::tuple_element_t<idx,alltypes>>...> ();
        //   ith item in the tuple -^        ^- one of our tuples T,U,V,W
    });
}

Demonstração