chiamata ricorsiva a lambda (C++ 11)

Question

Eventuali duplicati:
Recursive lambda functions in c++0x

Perché non posso chiamare un lambda in modo ricorsivo se scrivo come:

auto a = [&] 
{ 
    static int i = 0; i++; 
    std::cout << i << std::endl; 
    if (i<10) 
    a(); //recursive call 
}; 

Fornisce errore di compilazione (ideone):

prog.cpp:8:18: error: '((const main()::<lambda()>*)this)->main()::<lambda()>::a' cannot be used as a function 

prog.cpp: In function 'int main()': 
prog.cpp:9:9: error: variable 'auto a' with 'auto' type used in its own initializer 

Che cosa significa l'errore?

capisco il motivo per cui non riesco a scrivere questo:

auto i=i+1; //error: unable to deduce 'auto' from '<expression error>' 

Non possiamo scrivere questo perché il tipo di i deve essere dedotta dalla sua inizializzazione, il che significa che il tipo non si può dedurre se i appare nell'inizializzazione (ideone). Ma come importa in caso di lambda? Se non sbaglio, il tipo di lambda è determinato dal parametro (i) e dal tipo restituito; non dipende dal corpo se non restituisce nulla (nel qual caso il tipo di ritorno è dedotto come void, indipendentemente dalle altre dichiarazioni nel corpo lambda).

In ogni caso, ho ottenuto una soluzione, e posso usare std::function invece come:

std::function<void()> a = [&] 
{ 
    static int i = 0; i++; 
    std::cout << i << std::endl; 
    if (i<10) 
     a(); 
}; 

che compilare multe (ideone). Ma sono ancora interessato a conoscere il motivo per cui la versione auto non viene compilata.

Answer 1

Il motivo è che non vi è alcun caso speciale per gli inizializzatori di espressione lambda delle variabili auto.

Tali casi speciali sarebbero soggetti a errori e abusi. È necessario definire le regole quando si propone che qualcosa come a() dovrebbe funzionare. Come viene visualizzato lo operator()? Qual è lo stato preciso del tipo di a? Il tipo sarà completo? (il che implica che tu già conosci la lista di cattura del lambda). Dopo averlo formulato in un formato ragionevole per una specifica, sarebbe più facile fare dichiarazioni su di esso.

Permettere vostro caso d'uso significherebbe un altro caso in cui è necessario eseguire la scansione avanti nel codice, perché per determinare il tipo di a in a() si deve essere sicuri che l'inizializzazione si conclude con nulla che potrebbe "unlambda" il tipo

struct y { void operator()() { } }; 
template<typename T> y operator+(T, y) { return y(); } 
auto x = [] { x(); } + y(); 

In questo caso, x() chiamerebbe y::operator(), non la lambda.

Come ora, è semplicemente vietato digitare a nell'intero inizializzatore. Perché in C++, auto è non un tipo. È semplicemente un tipo specificatore che sta per un tipo da dedurre. Di conseguenza, un'espressione non può mai avere il tipo auto.

Answer 2

come la vedo io l'importante differenza tra il auto a caso e il caso std::function<void()> a è che il tipo std::function<void()> non sa/cura su ciò che il tipo di funzione reale si riferisce in realtà è. Scrittura:

std::function<void()> a; 

è perfettamente bene, dove, come:

auto a; 

ha poco senso. Quindi, quando arriva il momento di sintetizzare l'acquisizione se si utilizza std::function<void()>, tutto ciò che deve essere conosciuto sul tipo è già noto, mentre con auto non è ancora noto.

Answer 3

In una funzione ricorsiva f è definita da f e tipo di f è determinato anche dalla f in caso di auto ritorno che porta alla ricorsione infinita.

quando auto tenta di derivare un tipo. decltype (f()) si dedurrà ulteriormente ad un altro decltype (f) `come f deriva da f e.g. anche una chiamata a qualcosa di ricorsivo è ricorsiva. la determinazione del tipo di ritorno diventa ricorsiva se applicata a una funzione ricorsiva. in una funzione ricorsiva la fine della ricorsione può essere eseguita in runtime. ma la determinazione è statica solo