c++0x : bonne façon de recevoir un lambda en paramètre par référence

Question

Quelle est la bonne façon de définir une fonction qui reçoit un int->int par référence ?

 void f(std::function< int(int) >& lambda);

ou alors

 void f(auto& lambda);

Je ne suis pas sûr que la dernière forme soit même une syntaxe légale.

Existe-t-il d'autres façons de définir un paramètre lambda ?

Answer 1

J'utiliserais template comme :

 template<typename Functor>
void f(Functor functor)
{
   cout << functor(10) << endl;
}

int g(int x)
{
    return x * x;
}
int main() 
{
    auto lambda = [] (int x) { cout << x * 50 << endl; return x * 100; };
    f(lambda); //pass lambda
    f(g);      //pass function 
}

Production:

 500
1000
100

Démo : http://www.ideone.com/EayVq

Answer 2

Je sais que cela fait 7 ans, mais voici un moyen que personne d'autre n'a mentionné :

 void foo(void (*f)(int)){
    std::cout<<"foo"<<std::endl;
    f(1); // calls lambda which takes an int and returns void
}
int main(){
    foo([](int a){std::cout<<"lambda "<<a<<std::endl;});
}

Quelles sorties :

 foo
lambda 1

Pas besoin de modèles ou de std :: fonction

Answer 3

void f(auto& lambda);

C'est proche. Ce qui va réellement compiler est :

 #include <cassert>

/*constexpr optional*/ const auto f = [](auto &&lambda)
{
  lambda();
  lambda();
};

int main()
{
  int counter = 0;
  f([&]{ ++counter; });
  assert(counter == 2);
}