argument de modèle de déduction ou de substitution d'échec, lors de l'utilisation de std::function et std::bind

J'ai une erreur de compilation lors de l'utilisation de std::function dans basé sur un modèle de fonction de membre de, le code suivant est un exemple 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;
}

Et venir avec l'erreur de compilation suivante:

testtemplate.cpp: In function ‘int main()’:

testtemplate.rpc:29:92: error: no matching function for call pour
"Test::setCallback(std::_Bind_helper)(int, int),
TestA, const std::_Placeholder<1>&, const
std::_Placeholder<2>&>::type)’

testtemplate.rpc:29:92: remarque: le candidat est: testtemplate.rpc:10:7:
note: template void Test::setCallback(std::function)

testtemplate.rpc:10:7: remarque: l'argument de modèle
déduction ou de substitution d'échec:

testtemplate.rpc:29:92: note: ‘std::_Bind(TestA*, std::_Placeholder<1>,
std::_Placeholder<2>)> "n'est pas dérivé de" std::function’

Je suis à l'aide de C++11 et g++ 4.7

  • Dire test.setCallback<int>(bind...). Le résultat de bind n'est pas un std::function, donc il n'y a pas d'argument à déduction.
  • S'il vous plaît dites-moi comment vous pensez que le compilateur pourrait éventuellement comprendre ce qu'il faut en déduire T pour.
  • Je suis un étudiant de première année de modèle, je ne sais pas comment le dedece T de travail.certaines matières de l'aide?
  • En général, lorsque std::function est un paramètre, vous devez préciser le type pleinement à moins que vous passiez un std::function.
InformationsquelleAutor haipeng31 | 2013-03-21
  1. 11

    De comprendre le problème de laisser des instructions distinctes:

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

    setCallback besoins de connaître le type de T et il ne peut pas la déduire de f, afin de lui donner un type

    test.setCallback<TYPE>(f); //TYPE: int, float, a class, ...
    • le modèle est tellement dur, j'utilise un après-midi entier à faire face à ce problème,et enfin, je ne peux pas résoudre, merci pour votre explication. en passant, pouvez-vous me donner quelques conseils sur la learing modèle
    • Le programme et la pratique de tous les jours, C'est la seule façon d'apprendre les concepts de la programmation. La façon dont nous l'avons tous fait. Et de lire Q&A partir de Stackoverflow.
    InformationsquelleAutor deepmax
  2. 0

    Vous pouvez faire le type de déduction de travail avec la variante d':

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

    Cette façon de RAPPEL peut être déterminé en examinant l'argument. Il pourrait avoir des ennuis si bind n'a pas fait de retour d'un std::function, mais plutôt quelque chose qui peut être jeté comme un. Je ne suis pas sûr.

    InformationsquelleAutor dspeyer