C++ 0x: modo corretto per ricevere un lambda come parametro per riferimento

Question

Qual è il modo corretto per definire una funzione che riceve un parametro lambda int->int per riferimento?

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

o

void f(auto& lambda); 

non sono sicuro l'ultima forma è anche la sintassi legale.

Esistono altri modi per definire un parametro lambda?

Answer 1

Non è possibile avere un parametro auto. Fondamentalmente hai due opzioni:

Opzione 1: usa std::function come hai mostrato.

Opzione # 2: utilizzare un parametro di modello:

template<typename F> 
void f(F &lambda) { /* ... */} 

Opzione # 2 può, in alcuni casi, essere più efficiente, in quanto si può evitare una dotazione potenziale heap per l'oggetto funzione lambda incorporato, ma è possibile solo se f può essere inserito in un'intestazione come una funzione modello. Può anche aumentare i tempi di compilazione e l'impronta di I-cache, come qualsiasi modello. Si noti che potrebbe non avere alcun effetto, come se l'oggetto funzione lambda fosse abbastanza piccolo da poter essere rappresentato in linea nell'oggetto std::function.

Answer 2

userei template come:

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 
} 

uscita:

500 
1000 
100 

Demo: http://www.ideone.com/EayVq

Answer 3

So che questa domanda è già stato risposto, ma quando ero alla ricerca di una risposta a questa domanda, stavo cercando qualcosa di diverso rispetto alle risposte qui, e penso che questo potrebbe essere stato ciò a cui alludeva l'OP, quindi spero questo aiuterà qualcun altro.

Diciamo che avete una funzione:

void print(int n) 
{ 
    printf("%i ", n); 
} 

per passare un lambda a questa funzione, effettuare le seguenti operazioni:

print([]{ 
    return 3; 
}()); 

Questa passerà 3 alla funzione, ovviamente. Un esempio più utile, in particolare legati alla domanda del PO, è un lambda che prende un intero come parametro e restituisce un int alla funzione fine:

int x = 3; 

auto lambdaFunction = [](int input) { 
    return (input + 1); 
}; 

print(lambdaFunction(x)); 

Ciò presuppone non passa per valore o per riferimento al lambda, che puoi fare direttamente:

// Pass by value 
print([=]{ 
    return (x + 1); 
}()); 

// Pass by reference 
print([&]{ 
    return (x + 1); 
}());