c ++ functor e modelos de function

considere este código simples e sem sentido.

#include  struct A { template void test() { std::cout << N << std::endl; } }; int main() { A a; a.test(); } 

É um exemplo muito simples de um modelo de function. E se, no entanto, eu quisesse replace A::test por um operator() sobrecarregado operator() para torná-lo um functor?

 #include  struct A { template void operator()() { std::cout << N << std::endl; } }; int main() { A a; a(); // <-- error, how do I do this? } 

Certamente, se o operator() usasse parâmetros que dependessem do modelo, o compilador poderia deduzir o modelo. Mas eu simplesmente não consigo descobrir a syntax adequada para especificar parâmetros de modelo com um functor sem parâmetros.

Existe uma maneira correta de fazer isso?

Obviamente, esse código funcionaria, pois ignora a syntax do functor:

 a.operator()(); 

mas isso meio que anula o propósito de ser um functor: -P.

Não há outro jeito “direto” que conheço além do:

  a.operator()<1>(); 

syntax. Se você está aberto para mudar o código, mover o parâmetro template para a class funcionaria, ou usando um (boost | tr1) :: bind para fazer um object (boost | tr1) :: function.

Você só pode ligar

 a.operator()<1>(); 

mas isso não estaria usando um functor. Os operadores precisam de um operador não modelo (), pois eles devem poder ser chamados de varname () e isso não funcionará com seu código.

Para torná-lo um verdadeiro functor, mude seu código para uma class template (functores são classs):

 #include  template struct A { void operator()() { std::cout << N << std::endl; } }; int main() { A<1> a; a(); } 

Você está tentando passar um parâmetro de modelo para uma instância de um object, que, até onde eu sei, não é permitido. Você só pode passar parâmetros de modelos para funções de modelo ou objects de modelo.

a.test <1> (); e a.operator () <1> (); trabalho porque eles estão servindo como funções de modelo.

Use boost :: bind (confira as bibliotecas de reforço) para consertá-lo.

 struct A { void operator()(int n) { std::cout << n << std::endl; } }; int main(int argc, char* argv[]) { A a; boost::function f = boost::bind(a, 1); f(); // prints 1 return 0; } 

E você não precisa nem mexer com modelos!

Você está preso. Você já considerou algo como

 struct A { template struct B { void operator()() { std::cout << N << std::endl; } }; template B functor() {return B();} }; int main() { A a; a.functor<1>()(); } 

Não, não há maneira de contornar isso. Como você disse, você precisa chamar o operador explicitamente (o que anula o propósito) ou os argumentos do modelo devem poder ser deduzidos pelo compilador.