Supongamos que tenemos

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

definido. Ahora quiero implementar

do_foo(unsigned n);

que llama a la variante correspondiente defoo(). Este no es simplemente un ejemplo sintético: esto realmente sucede en la vida real (por supuesto, no necesariamente con funciones de vacío a vacío y solo un parámetro de plantilla, pero estoy simplificando. Por supuesto, en C ++, no podemos tener lo siguiente:

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

y lo que hago ahora es

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;
    }
}

cuando sé que n está efectivamente limitado en rango a n_1, ..., n_k. Pero esto es indecoroso, y mucho más cuando la llamada es más larga y necesito duplicar una larga secuencia de plantillas y parámetros regulares muchas veces.

Estaba a punto de comenzar a trabajar en una macro para producir estas declaraciones de cambio, cuando pensé que tal vez alguien ya había trabajado en esto en alguna biblioteca y podría compartir lo que hizo. De lo contrario, quizás todavía sea factible tener algún tipo de construcción C ++ que tome una función arbitraria, con cualquier secuencia de parámetros de plantilla y no de plantilla, incluido algún parámetro de plantilla numérico, y una secuencia de valores en alguna forma, para producir un contenedor que puede tomar ese parámetro de plantilla como un parámetro de tiempo de ejecución adicional, p. ej.

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