Expresiones lambda en C ++

　　1. Una expresión simple de Lambda es la siguiente:
　　
　　[] {};
　　
　　Esto define un objeto, este objeto es anónimo, recuerde, la expresión de Lambda es un objeto, no un tipo, ¡esto es muy importante! En este ejemplo, el tipo de objeto es 'anonymous-namespace' :: <lambda0>, que es un nombre de tipo que le da el compilador.
　　
　　2. Generalmente, cuando un compilador implementa una expresión Lambda, la convierte en un objeto de función (functor). Por ejemplo, el ejemplo anterior se transformará en la
　　
　　estructura A {
　　
　　public:
　　
　　void operator () () const {}
　　
　　};
　　
　　A ();
　　
　　donde A () es un objeto de función y A es un tipo, estos deben distinguirse claramente.
　　
　　3. Los functores y las expresiones Lambda pueden tener estado, lo que significa que pueden contener miembros de datos y los punteros de función no tienen estado. Por ejemplo, en los siguientes casos, no se pueden usar punteros de función, solo functores o Lambda Expresión
　　
　　/ ************************************************* *******************
　　
　　creado: 2014/05/07 22:31
　　
　　nombre de archivo: main.cpp
　　
　　autor: Justme0 (http://blog.csdn.net/justme0)
　　
　　propósito: cuando se trata de estado, solo puede usar functores o expresiones Lambda, no punteros de función
　　
　　************************************************** ******************* /
　　
　　#include <iostream>
　　
　　#include <vector>
　　
　　#include <algorithm>
　　
　　usando el espacio de nombres estándar;
　　
　　/ *
　　
　　** 输出 vec 中 大于 estándar 的 元素
　　
　　* /
　　
　　void print_use_lambda (const vector <int> & vec, int standard) {
　　
　　for_each (vec.begin (), vec.end (), [standard] (int elem) {
　　
　　if (estándar <elem) {
　　
　　cout << elem << '';
　　
　　}
　　
　　});
　　
　　}
　　
　　struct Printor {
　　
　　privado:
　　
　　int m_standard;
　　
　　public:
　　
　　Printor (int estándar): m_standard (estándar) {}
　　
　　operador vacío () (int elem) const {
　　
　　if (m_standard <elem) {
　　
　　cout <<
　　
　　}
　　
　　}
　　
　　};
　　
　　/ *
　　
　　** Elementos de salida mayores que el estándar en vec
　　
　　* /
　　
　　void print_use_functor (const vector <int> & vec, int standard) {
　　
　　for_each (vec.begin (), vec.end (), Printor (standard)) ;
　　
　　}
　　
　　int main (int argc, char ** argv) {
　　
　　int arr [] = {5, 2, 1, 4, 5, 6, 7, 2};
　　
　　int size = sizeof arr / sizeof * arr;
　　
　　vector <int > vec (arr, arr + size);
　　
　　cout << "¿necesita imprimir más de qué número?" << endl;
　　
　　int standard;
　　
　　cin >> standard;
　　
　　print_use_functor (vec, standard);
　　
　　cout << endl;
　　
　　print_use_lambda (vec, estándar);
　　
　　cout << endl;
　　
　　system ("PAUSE");
　　
　　return 0;
　　
　　}
　　
　　Al llamar a for_each en el programa, solo se generan elementos superiores a un número determinado, y este número no se conoce de antemano, este número representa el estado del functor, y si usa un puntero de función, no puede obtener este número (estado), preste atención al tercero de for_each Los parámetros son unarios.
　　
　　4. Pasar la lista de captura por valor es diferente de pasar la lista por referencia Tome el siguiente programa como ejemplo:
　　
　　/ ************************** ******************************************
　　
　　creado: 2014/05/06 21 : 01
　　
　　nombre de archivo: main2.cpp
　　
　　autor: Justme0 (http://blog.csdn.net/justme0)
　　
　　propósito: Lista de captura de Lambda
　　
　　********************* ************************************************ /
　　
　　# incluir <iostream>
　　
　　usando el espacio de nombres std;
　　
　　int main (int argc, char ** argv) {
　　
　　int i = 0;
　　
　　auto by_val_lambda = [i] {
　　
　　return i;
　　
　　};
　　
　　auto by_ref_lambda = [& i] {
　　
　　return i;
　　
　　};
　　
　　cout << by_val_lambda () << endl; // 0
　　
　　cout << by_ref_lambda () << endl; // 0
　　
　　++ i;
　　
　　cout << by_val_lambda () << endl; // 0
　　
　　cout << by_ref_lambda () << endl; // 1
　　
　　sistema ("PAUSE");
　　
　　return 0;
　　
　　}
　　
　　Para explicar este problema, conviértalos en functors (implementación del compilador) de un vistazo:
　　
　　/ ************************ ************************************************
　　
　　creado: 2014/05 / 06 20:39
　　
　　nombre de archivo: main.cpp
　　
　　autor: Justme0 (http://blog.csdn.net/justme0)
　　
　　propósito: usar Functor en lugar de Lambda
　　
　　******************* ************************************************** /
　　
　　#incluye <iostream>
　　
　　usando el espacio de nombres std;
　　
　　struct Value {
　　
　　private:
　　
　　int m_i;
　　
　　public:
　　
　　Value (int i):m_i (i) {}
　　
　　int operador () () const {
　　
　　return m_i;
　　
　　}
　　
　　};
　　
　　referencia de estructura {
　　
　　privado:
　　
　　int & m_i;
　　
　　public:
　　
　　Referencia (int & i): m_i (i) {} // 必须 用 初始化 列表
　　
　　int operator () () const {
　　
　　return m_i;
　　
　　}
　　
　　};
　　
　　puntero de estructura {
　　
　　privado:
　　
　　int * m_pi;
　　
　　public:
　　
　　Puntero (int * pi): m_pi (pi) {}
　　
　　int operator () () const {
　　
　　return * m_pi;
　　
　　}
　　
　　};
　　
　　int main (int argc, char ** argv) {
　　
　　int i = 0;
　　
　　auto by_val_functor = Valor (i);
　　
　　auto by_ref_functor = Referencia (i);
　　
　　auto by_ptr_functor = Puntero (& i);
　　
　　cout << by_val_functor () << endl; // 0
　　
　　cout << by_ref_functor () << endl; // 0
　　
　　cout << by_ptr_functor () << endl; // 0
　　
　　++ i;
　　
　　cout << by_val_functor () < <endl; // 0
　　
　　cout << by_ref_functor () << endl; // 1
　　
　　cout << by_ptr_functor () << endl; // 1
　　
　　sistema ("PAUSE");
　　
　　return 0;
　　
　　}
　　
　　Lambda guardó uno cuando se pasó el valor La copia no tiene nada que ver con los parámetros formales. Cuando se pasa la referencia, Lambda guarda la referencia del parámetro formal, por lo que cuando el parámetro formal ++ i se cambia más tarde, el i señalado por la referencia guardada en Lambda cambia (el mismo i). Tenga en cuenta que el puntero es similar a la referencia. Use el puntero para explicar la referencia No podría ser mejor.
　　
　　5. La lista de captura Lambda solo puede capturar variables automáticas en el ámbito primario.
　　
　　El estándar se define de esta manera, pero algunos compiladores no cumplen, y el autor tiene dudas sobre las reglas específicas. Pero, en general, la idea de Lambda se limita a un ámbito local, si necesita compartir globalmente, use punteros de función (sin estado) o functores (con estado).