C++ 11 Función de plantilla que toma una función std :: que depende de los parámetros de la plantilla

Question

Estoy tratando de escribir una función de plantilla que acepte un std::function que depende de los argumentos de la plantilla. Lamentablemente, el compilador no es capaz de deducir correctamente los argumentos al std::function. Aquí algunos simples código de ejemplo:

#include <iostream> 
#include <functional> 

using namespace std; 

void DoSomething(unsigned ident, unsigned param) 
{ 
    cout << "DoSomething called, ident = " << ident << ", param = " << param << "\n"; 
} 

template < typename Ident, typename Param > 
void CallFunc(Ident ident, Param param, std::function< void (Ident, Param) > op) 
{ 
    op(ident, param); 
} 

int main() 
{ 
    unsigned id(1); 
    unsigned param(1); 

    // The following fails to compile 
    // CallFunc(id, param, DoSomething); 

    // this is ok 
    std::function< void (unsigned, unsigned) > func(DoSomething); 
    CallFunc(id, param, func); 

    return 0; 
} 

Si llamo al molde con el siguiente:

CallFunc(id, param, DoSomething); 

consigo los siguientes errores:

function-tpl.cpp:25: error: no matching function for call to CallFunc(unsigned int&, unsigned int&, void (&)(unsigned int, unsigned int))

Si creo explícitamente un std :: función del tipo correcto (o emitirlo) el problema desaparece:

std::function< void (unsigned, unsigned) > func(DoSomething); 
CallFunc(id, param, func); 

¿Cómo codificaría esto para que no se necesite el temporal explícito?

Answer 1

Si está utilizando las plantillas, puede evitar std::function por completo, a menos que por alguna razón desea restringir específicamente la función para tomar std::function:

template < typename Ident, typename Param, typename Func > 
void CallFunc(Ident ident, Param param, Func op) 
{ 
    op(ident, param); 
} 

Answer 2

Puede hacer la conversión en línea o usar bind. Tampoco es especialmente bonita, pero que se hagan el trabajo:

CallFunc(id, param, std::function<void(unsigned, unsigned)>(DoSomething)); 

CallFunc(id, param, std::bind(DoSomething, std::placeholders::_1, std::placeholders::_2)); 

Answer 3

Es necesario que el tercer parámetro de función sea un contexto no deducido para los parámetros de la plantilla en el mismo. Entonces el compilador no comparará el tipo de argumento con el tipo de parámetro sin considerar todas las conversiones implícitas (el Estándar dice, y C++ 0x clarificó esto aún más, que para un parámetro de función donde no hay parámetros de plantilla para deducir posiciones, todos implícitos se permiten conversiones para salvar una diferencia).

template < typename T > struct id { typedef T type; }; 

template < typename Ident, typename Param > 
void CallFunc(Ident ident, Param param, 
       typename id<std::function< void (Ident, Param) >>::type op) 
{ 
    op(ident, param); 
} 

En lugar de id puede utilizar boost::identity. En C++ 0x y compiladores que lo apoyan, puede tener una edición más legible el uso de plantillas de alias

template < typename T > using nondeduced = typename id<T>::type; 

A continuación, el código se convierte simplemente en

template < typename Ident, typename Param > 
void CallFunc(Ident ident, Param param, 
       std::function< nondeduced<void (Ident, Param)> > op) 
{ 
    op(ident, param); 
} 

Sin embargo GCC aún no soporta plantillas de alias.