Sovraccarico di lambda ricorsivo

Question

Le funzioni lambda ricorsive inducono qualsiasi overhead a confronto con le funzioni ricorsive regolari (poiché dobbiamo acquisirle in una funzione std ::)?
Qual è la differenza tra questa funzione e una simile utilizzando solo le funzioni regolari?

int main(int argc, const char *argv[]) 
{ 
    std::function<void (int)> helloworld = [&helloworld](int count) { 
     std::cout << "Hello world" << std::endl; 
     if (count > 1) helloworld(--count); 
    }; 
    helloworld(2); 
    return 0; 
} 

Answer 1

C'è sovraccarico utilizzando lambda ricorsivamente memorizzando come std::function, anche se sono fondamentalmente stessa funtori. Sembra che gcc non sia in grado di ottimizzare bene il che può essere visto in diretta comparison.

L'implementazione del comportamento di una lambda, ovvero la creazione di un functor, abilita nuovamente l'ottimizzazione gcc. Il tuo esempio specifico di un lambda potrebbe essere implementato come

struct HelloWorldFunctor 
{ 
    void operator()(int count) const 
    { 
     std::cout << "Hello world" << std::endl; 
     if (count > 1) 
     { 
     this->operator()(count - 1); 
     } 
    } 
}; 
int main() 
{ 
    HelloWorldFunctor functor; 
    functor(2); 
} 

Per l'esempio ho creato il funtore sarebbe simile in questo second demo.

Anche se si introduce chiamate a funzioni quali impuri std::rand, le prestazioni senza un ricorsiva lambda o con un funtore personalizzato è ancora meglio. Ecco uno third demo.

Conclusione: con l'utilizzo di un std::function, c'è un sovraccarico, anche se potrebbe essere trascurabile a seconda del caso d'uso. Poiché questo utilizzo impedisce alcune ottimizzazioni del compilatore, questo non dovrebbe essere ampiamente utilizzato.

Answer 2

lambda in C++ sono equivalenti a funtori quindi sarebbe la stessa che chiama l'operatore() di una classe creata automaticamente dal compilatore. Quando si cattura l'ambiente, ciò che accade dietro le quinte è che quelle variabili catturate vengono passate al costruttore della classe e memorizzate come variabili membro.

Quindi, in breve, la differenza di prestazioni dovrebbe essere molto vicina allo zero.

Qui c'è qualche ulteriore spiegazione: "Come sono Lambda Chiusure implementato"

Vai alla sezione http://www.cprogramming.com/c++11/c++11-lambda-closures.html

EDIT:

Dopo alcune ricerche e grazie a Stefan risposta e il codice, si è scoperto che v'è un sovraccarico sulla ricorsive lambda a causa della std :: funzione di linguaggio. Poiché lambda deve essere incapsulato su una funzione std :: per chiamare se stesso, si tratta di chiamare una funzione virtuale che compie aggiungendo un sovraccarico.

Il soggetto viene trattato sulle osservazioni di questa risposta: https://stackoverflow.com/a/14591727/1112142

Answer 3

Quindi std::function viene implementato in modo polimorfico. Significato il codice è più o meno equivalente a:

struct B 
{ 
    virtual void do(int count) = 0; 
}; 

struct D 
{ 
    B* b; 
    virtual void do(int count) 
    { 
     if (count > 1) 
      b->do(count--); 
    } 
}; 

int main() 
{ 
    D d; 
    d.b = &d; 
    d.do(10); 
} 

E 'raro avere una sufficiente ricorsione stretta tale che un metodo di ricerca virtuale è un overhead significativo, ma a seconda del campo di applicazione è certamente possibile.