Suponha que tenhamos

template <unsigned N> foo() { /* ... */ }

definiram. Agora eu quero implementar

do_foo(unsigned n);

que chama a variante correspondente defoo(). Este não é apenas um exemplo sintético - isso realmente acontece na vida real (é claro, não necessariamente com funções de vazio para vazio e apenas um parâmetro de modelo, mas estou simplificando. Claro, em C ++, não podemos tem o seguinte:

do_foo(unsigned n) { foo<n>(); }

e o que eu faço agora é

do_foo(unsigned n) { 
    switch(n) {    
    case n_1: foo<n_1>(); break;
    case n_2: foo<n_2>(); break;
    /* ... */
    case n_k: foo<n_k>(); break;
    }
}

quando eu sei que n está efetivamente limitado em n_1, ..., n_k. Mas isso é impróprio e muito mais quando a chamada é mais longa e preciso duplicar uma longa sequência de modelos e parâmetros regulares várias vezes.

Eu estava prestes a começar a trabalhar em uma macro para produzir essas instruções de mudança, quando pensei que talvez alguém já tenha trabalhado nisso em alguma biblioteca e possa compartilhar o que fez. Caso contrário, talvez ainda seja viável ter algum tipo de construção C ++ que execute uma função arbitrária, com qualquer sequência de parâmetros de modelo e sem modelo, incluindo algum parâmetro numérico de modelo e uma sequência de valores de alguma forma, para produzir um invólucro que pode usar esse parâmetro de modelo como um parâmetro de tempo de execução adicional, por exemplo,

auto& transformed_foo = magic<decltype(foo)>(foo)::transformed;