¿Es posible pasar una plantilla de función como argumento de plantilla? asssume

Question

Vamos, que tenemos una funcion plantilla:

template<typename T1, typename T2, typename T3> 
T3 such_fun(T1 a, T2 b) { 
    // do something... 
} 

y ahora queremos utilizarlo como un argumento en otra plantilla, por ejemplo, como ese

template<typename T1, template<typename, typename, typename> some_function> 
void big_fun(T1 a) { 
    // some code... 
    a = some_function<T1, T1, T1>(a, a); 
    // some code... 
} 

¿Es posible?

Sé que puedo usar una estructura con el operador defined(). Solo tengo curiosidad acerca de las funciones.

EDIT:

Mientras estaba escribiendo esa pregunta mi amigo encontró una solución parcial:

template<typename T1, T1 (*some_function)(T1, T1)> 
void big_fun(T1 a) { 
    // some code... 
    a = some_function(a, a); 
    // some code... 
} 

Pero aún así - Soy curioso si es posible sin una materialización de un tipo de función antes llamada. Por ejemplo, es posible que desee llamar a la plantilla pasada con varias combinaciones de tipos:

template<typename T1, typename T2, template<typename, typename, typename> some_function> 
void big_fun(T1 a, T2 b) { 
    // some code... 
    a = some_function<T1, T1, T1>(a, a); 
    a = some_function<T1, T2, T1>(a, b); 
    b = some_function<T2, T2, T2>(b, b); 
    b = some_function<T2, T1, T2>(b, a); 
    // some code... 
} 

Answer 1

No, esto no es posible. De 14.3.3 en el N3337:

Una plantilla-argumento a favor de una plantilla-parámetro de plantilla será el nombre de una plantilla de clase o de una plantilla de alias, expresado como id-expresión. Cuando el argumento de la plantilla nombra una plantilla de clase, , solo se consideran las plantillas de clases primarias al hacer coincidir el argumento de la plantilla con el parámetro correspondiente; las especializaciones parciales no se consideran incluso si sus listas de parámetros coinciden con el del parámetro plantilla de plantilla.

El primer párrafo solo menciona explícitamente plantillas de clase. Supongo que tampoco vale la pena, ya que puedes hacer algo muy similar con funciones o un std::function como argumento.

Answer 2

Las plantillas en C++ se compilan durante el tiempo de compilación utilizando los tipos concretos. Ellos deben ser conocidos.

Esto dice que puede ir un poco más allá con su solución parcial al pasar una plantilla de función cuyos argumentos se pueden deducir. Tenga en cuenta que esto no es diferente a la función de pasar explícitamente con tipos concretos, solo tiene que escribir menos.

template<typename T> 
T square(T a, T b) 
{ 
    return a * b; 
} 

template<typename T, T (*some_function)(T, T)> 
T test(T a) 
{ 
    return square (a, a); 
} 

void main() 
{ 
    int a = test<int, square>(2); 
    float b = test<float, square>(2.2f); 
} 

Answer 3

Mientras template< typename T1, typename T2, typename T3> someTemplate evalúa en cierta clase real y sin errores que se puede utilizar la mayor cantidad de combinaciones que desee, y dentro de otras plantillas.

¿Has intentado compilarlo? Muéstranos qué error obtienes (y muestra concreta)