Idioma para simular parâmetros numéricos de modelo em tempo de execução?
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;