una tener son que puede programacion pasar parametros parametro los hay función funcion formas cuantos argumentos argumento c++ function templates bind

c++ - tener - que es un argumento o parametro en programacion



la deducción/sustitución de los argumentos de la plantilla falló, al usar std:: function y std:: bind (2)

Para resolver el problema, deje declaraciones separadas:

auto f = bind(&TestA::testa, &testA, _1, _2); // OK test.setCallback(f); // <<--- Error is here

setCallback necesita saber el tipo de T y no puede deducirlo de f , así que dale un tipo

test.setCallback<TYPE>(f); // TYPE: int, float, a class, ...

Tengo un error de compilación cuando uso la función std :: en una función miembro con plantilla, el siguiente código es un ejemplo simple:

#include <functional> #include <memory> using std::function; using std::bind; using std::shared_ptr; class Test { public: template <typename T> void setCallback(function<void (T, int)> cb); }; template <typename T> void Test::setCallback(function<void (T, int)> cb) { // do nothing } class TestA { public: void testa(int a, int b) { } }; int main() { TestA testA; Test test; test.setCallback(bind(&TestA::testa, &testA, std::placeholders::_1, std::placeholders::_2)); return 0; }

Y ven con el siguiente error de compilación:

testtemplate.cpp: en la función ''int main ()'':

testtemplate.cpp: 29: 92: error: no hay función coincidente para la llamada a ''Test :: setCallback (std :: _ Bind_helper) (int, int), TestA, const std :: _ Placeholder <1> &, const std :: _ Placeholder <2> &> :: type) ''

testtemplate.cpp: 29: 92: note: el candidato es: testtemplate.cpp: 10: 7: note: template void Test :: setCallback (std :: function)

testtemplate.cpp: 10: 7: nota: la deducción / sustitución del argumento de la plantilla falló:

testtemplate.cpp: 29: 92: note: ''std :: _ Bind (TestA *, std :: _ Placeholder <1>, std :: _ Placeholder <2>)>'' no se deriva de ''std :: function''

Estoy usando C ++ 11 y g ++ 4.7


Puedes hacer que la deducción de tipos funcione con alguna variante de:

template<typename CALLBACK> void setCallback(CALLBACK cb) { typedef CALLBACK::first_argument_type T; static_assert(is_same_type<CALLBACK,function<void(T,int)>>::value); ... }

De esta manera, CALLBACK puede determinarse mirando el argumento. Podría meterse en problemas si bind no devuelve una función std :: sino algo que se puede convertir como una. No estoy seguro.