In che tipo vengono compilati i lambda?

Question

Poiché so che tutti i tipi di dati devono essere noti al momento della compilazione e lambda non è un tipo. Lambda è stato tradotto in anonymous struct with operator() o std::function incartato?

Ad esempio,

std::for_each(v.begin(), v.end(), [](int n&){n++;}); 

Answer 1

Una variante del as-if rule, lo standard C++ 11 dice :

§5.1.2/3 [..] L'esecuzione può definire il tipo di chiusura diversamente da quanto descritto qui di seguito fornita ciò non altera il comportamento osservabile del programma diverso modificando:

- la dimensione e/o allineamento del tipo di chiusura,

- se il tipo di chiusura è banalmente copiabile (clausola 9),

- se il tipo di chiusura è una classe standard di layout (clausola 9), o

- se il tipo di chiusura è una classe POD (Clausola 9).

Credo che questo sia ciò che le persone intendono quando dicono che è unspecified. Tuttavia ciò che è garantito come già detto nelle altre risposte è la seguente:

autore originale: Lightness Races in Orbit

[C++11: 5.1.2/3]:Il tipo di lambda-espressione (che è anche il tipo di chiusura oggetto) è un unico, senza nome non sindacale tipo di classe - chiamato il tipo chiusura - le cui proprietà sono d indicato di seguito. Questo tipo di classe non è un aggregato (8.5.1). Il tipo di chiusura viene dichiarato nell'ambito di ambito più piccolo, nell'ambito della classe o nell'ambito dello spazio dei nomi che contiene la corrispondente espressione lambda. [..]

La clausola prosegue elencando diverse proprietà di questo tipo. Qui alcuni punti salienti:

[C++11: 5.1.2/5]: Il tipo di chiusura per un lambda-espressione ha un pubblico inline operatore chiamata di funzione (13.5.4) i cui parametri e tipo di ritorno sono descritti dalla lambda-espressione parametro-dichiarazione-clausola e trailing-return-type rispettivamente. [..]

[C++11: 5.1.2/6]: Il tipo di chiusura per una lambda-espressione senza lambda-capture ha un non-esplicito const pubblica funzione non virtuale conversione a puntatore a funzione con lo stesso parametro e restituire i tipi come operatore di chiamata di funzione del tipo di chiusura. Il valore restituito da questa funzione di conversione deve essere l'indirizzo di una funzione che, se richiamata, ha lo stesso effetto del richiamo dell'operatore di chiamata di tipo del tipo di chiusura .

Answer 2

Un'espressione lambda costruisce un tipo senza nome, con ciascuno avente un tipo diverso. Non sono implementazioni std::function. Per saperne di più è fornito qui: What is a lambda expression in C++11? e qui: How to convert a lambda to an std::function using templates

Puoi svelare il tipo sul vostro compilatore specifico con un trucco del genere:

void foo(int); 

int main() { 
    auto a = []{ return 1; }; 
    auto b = []{ return 1; }; 

    foo(a); 

    foo(b); 

    return 0; 
} 

compilazione con clangore sul mio mac dà:

/Users/jcrotinger/ClionProjects/so_lambda_type/main.cpp:11:5: error: no matching function for call to 'foo' 
    foo(a); 
    ^~~ 
/Users/jcrotinger/ClionProjects/so_lambda_type/main.cpp:5:6: note: candidate function not viable: no known conversion from 
'<lambda at /Users/jcrotinger/ClionProjects/so_lambda_type/main.cpp:8:14>' to 'int' for 1st argument 
void foo(int); 
    ^
/Users/jcrotinger/ClionProjects/so_lambda_type/main.cpp:13:5: error: no matching function for call to 'foo' 
    foo(b); 
    ^~~ 
/Users/jcrotinger/ClionProjects/so_lambda_type/main.cpp:5:6: note: candidate function not viable: no known conversion from 
'<lambda at /Users/jcrotinger/ClionProjects/so_lambda_type/main.cpp:9:14>' to 'int' for 1st argument 
void foo(int); 

@Barry indica che è possibile utilizzare typeid invece. Se stampo fuori typeid(a).name() e typeid(b).name() sul mio sistema, ottengo:

Z4mainE3$_0 
Z4mainE3$_1 

che demangle a

main::$_0 
main::$_1 

Volevo solo includere questo per completezza. In realtà trovo la versione del messaggio di errore un po 'più informativa. :)

Answer 3

Dal §5.1.2.3 di serie:

Il tipo di lambda-espressione ... è un unico, senza nome non sindacale tipo di classe

E ' il suo tipo Ogni volta. Così, per esempio:

auto a = []{ return 1; }; 
auto b = []{ return 1; }; 

a e b avrà necessariamente tipi diversi. Sono entrambi convertibili in std::function<int()>, ma non gli uni agli altri:

std::function<int()> c = a; // OK 
a = b; // NOPE 

Aggiunta di un paio di esempi per aggiungere un po 'di chiarezza:

decltype(a) a2 = a; // OK, explicitly specifying the correct type 

template <typename F> 
void foo(F f) { ... } 

foo(a); // calls foo<decltype(a)>, not foo<std::function<int()>