Usando auto in una funzione lambda

Question

#include <vector> 
#include <algorithm> 

void foo(int) 
{ 
} 

int main() 
{ 
    std::vector<int> v({ 1,2,3 }); 

    std::for_each(v.begin(), v.end(), [](auto it) { foo(it+5); }); 
} 

Quando compilato, l'esempio precedente avvia l'uscita errore come questo:

h4.cpp: In function 'int main()': 
h4.cpp:13:47: error: parameter declared 'auto' 
h4.cpp: In lambda function: 
h4.cpp:13:59: error: 'it' was not declared in this scope 

Vuol dire che la parola chiave auto non deve essere usato nelle espressioni lambda?

Questo funziona:

std::for_each(v.begin(), v.end(), [](int it) { foo(it+5); }); 

Perché la versione con la parola chiave auto non funziona?

Answer 1

auto keyword non funziona come un tipo per argomenti di funzione. Se non si desidera utilizzare il tipo effettivo nelle funzioni lambda, è possibile utilizzare il codice riportato di seguito.

for_each(begin(v), end(v), [](decltype(*begin(v)) it){ 
     foo(it + 5);   
}); 

Answer 2

Il tipo di lambda deve essere conosciuto prima il compilatore può anche istanziare std::for_each. D'altra parte, anche se fosse teoricamente possibile, che auto potesse essere dedotto solo dopo che for_each è stato istanziato osservando come viene richiamato il functor.

Se possibile, dimenticare for_each, e utilizzare gamma-based per i cicli che sono molto più semplice:

for (int it : v) { 
    foo(it + 5); 
} 

Questo dovrebbe anche far fronte bene con auto (e auto& e const auto&).

for (auto it : v) { 
    foo(it + 5); 
} 

Answer 3

Questo è stato discusso brevemente da Herb Sutter durante un'intervista. La vostra richiesta di auto argomenti è infatti non è diverso da chiedendo che qualsiasi funzione dovrebbe essere dichiarabile con auto, in questo modo:

auto add(auto a, auto b) -> decltype(a + b) { return a + b; } 

Si noti tuttavia che questo non è davvero una funzione a tutti, ma piuttosto è un modello funzione di , simile a:

template <typename S, typename T> 
auto add(S a, T b) -> decltype(a + b) { return a + b; } 

Così si chiedono in sostanza di un impianto per trasformare qualsiasi funzione in un modello, cambiando i suoi argomenti. Poiché i template sono un tipo di entità molto diverso nel sistema dei tipi di C++ (pensate a tutte le regole speciali per i template, come la ricerca e la deduzione in due fasi), questo sarebbe un radicale cambiamento di design con implicazioni imprevedibili, che certamente non è t sarà nello standard in qualunque momento presto.

Answer 4

C++ 14 consente la dichiarazione della funzione lambda (funzione lambda generica) con l'auto.

auto multiply = [](auto a, auto b) {return a*b;}; 

Per ulteriori dettagli: http://en.cppreference.com/w/cpp/language/lambda