C++中的lambda表达式（匿名函数）

1.

lambda表达式是C++11中引入的一项新技术，利用lambda表达式可以编写内嵌的匿名函数，用以替换独立函数或者函数对象，并且使代码更可读.从广义上说，lambda表达式产生的是函数对象。函数对象的本质上是一个类而不是一个函数，在类中，对象重载了函数调用运算符()，从而使对象能够项函数一样被调用，我们称这些对象为函数对象（Function Object）或者仿函数（Functor）。lambda表达式最前面的方括号提供了“闭包”功能。每当定义一个lambda表达式以后，编译器会自动生成一个 匿名类 ，并且这个类重载了()运算符，我们将其称之为闭包类型（closure type）。在运行时，这个lambda表达式会返回一个匿名的闭包实例，并且该实例是一个右值。闭包的一个强大之处在于其可以通过传值或引用的方式捕捉其封装作用域内的变量，lambda表达式前面的方括号就是用来定义捕捉模式以及变量的lambda捕捉块
lambda表达式有如下优点：
(1) 声明式编程风格：就地匿名定义目标函数或函数对象，不需要额外写一个命名函数或者函数对象。以更直接的方式去写程序，好的可读性和可维护性。
(2) 简洁：不需要额外再写一个函数或者函数对象，避免了代码膨胀和功能分散，让开发者更加集中精力在手边的问题，同时也获取了更高的生产率。
(3) 在需要的时间和地点实现功能闭包，使程序更灵活

• 语法表达形式

[ capture ] ( params ) opt -> ret { body; };
1

lambda 表达式定义了一个匿名函数，并且可以捕获一定范围内的变量。
capture 是捕获列表，params 是参数表，opt 是函数选项，ret 是返回值类型，body是函数体,
这其中的->ret返回类型可以省略，lambda可以自动推导返回类型，如果不传参（）也可以省略
示例：

	auto func1 = []{
	cout << "hello world" << endl;
	};

1
2
3
4

• 带参数的：

	auto add = [](int a,int b){
		return a+b;
	};
	cout << "a+b = " << add(1,2)<<endl;
1
2
3
4

• 需要注意初始化列表不能用于返回值的自动推导：

auto x1 = [](int i){ return i; };  // OK: return type is int
auto x2 = [](){ return { 1, 2 }; };  // error: 无法推导出返回值类型
1
2

-使用 lambda 表达式捕获列表
lambda 表达式还可以通过捕获列表捕获一定范围内的变量：

[] 不捕获任何变量，试图在Lambda内使用任何外部变量都是错误的.
[x, &y]   //x 按值捕获, y 按引用捕获.
[&] 捕获外部作用域中所有变量，并作为引用在函数体中使用（按引用捕获）。
[=] 捕获外部作用域中所有变量，并作为副本在函数体中使用（按值捕获）。
[=，&foo] 按值捕获外部作用域中所有变量，并按引用捕获 foo 变量。
[&, x]    //x显式地按值捕获. 其它变量按引用捕获
[bar] 按值捕获 bar 变量，同时不捕获其他变量。
[this] 捕获当前类中的 this 指针，让 lambda 表达式拥有和当前类成员函数同样的访问权限。如果已经使用了 & 或者 =，就默认添加此选项。捕获 this 的目的是可以在 lamda 中使用当前类的成员函数和成员变量。
1
2
3
4
5
6
7
8

• 参数捕获

class temp
{
    public:
    int tmp = 0;
    void func(int a, int b)
    {
        // auto x1 = []{ 
		// 	return tmp; 
        // }; // error，没有捕获外部变量
        auto x2 = [=]{ 
			return tmp + a + b; 
        }; // OK，捕获所有外部变量
        auto x3 = [&]{ 
			return tmp + a + b; 
		}; // OK，捕获所有外部变量
        auto x4 = [this]{ 
			return tmp; 
		}; // OK，捕获this指针
        // auto x5 = [this]{ 
		// 	return tmp + a + b; 
		// }; // error，没有捕获x、y
        auto x6 = [this, a, b]{ 
			return tmp + a + b; 
		}; // OK，捕获this指针、x、y
        auto x7 = [this]{ 
			return tmp++; 
		}; // OK，捕获this指针，并修改成员的值
    }
};
void test02(void)
{

	auto a = 0, b = 1;
	// auto f1 = []{
	// 	return a; 
	// };  // error，没有捕获外部变量
	auto f2 = [&]{ 
		return a++; 
	};  // OK，捕获所有外部变量，并对a执行自加运算
	auto f3 = [=]{ 
		return a; 
	};  // OK，捕获所有外部变量，并返回a
	// auto f4 = [=]{ 
	// 	return a++; 
	// };  // error，a是以复制方式捕获的，无法修改
	// auto f5 = [a]{ 
	// 	return a + b; 
	// };  // error，没有捕获变量b
	auto f6 = [a, &b]{ 
		return a + (b++); 
	};  // OK，捕获a和b的引用，并对b做自加运算
	auto f7 = [=, &b]{ 
		return a + (b++); 
	};  // OK，捕获所有外部变量和b的引用，并对b做自加运算
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

这里需要注意的是[&]是捕获所有变量这里是按引用的方式来捕获的，而[=]是按照值捕获的。

• 关于延迟的问题

    int a = 0;
    auto f = [=]{ return a; };      // 按值捕获外部变量
    a += 1;                         // a被修改了
    cout << f() << endl;  // 输出？
1
2
3
4

在这个例子中，lambda 表达式按值捕获了所有外部变量。在捕获的一瞬间，a 的值就已经被复制到f中了。之后 a 被修改，但此时 f 中存储的 a 仍然还是捕获时的值，因此，最终输出结果是 0.
如果希望 lambda 表达式在调用时能够即时访问外部变量，我们应当使用引用方式捕获。
从上面的例子中我们知道，按值捕获得到的外部变量值是在 lambda 表达式定义时的值。此时所有外部变量均被复制了一份存储在 lambda 表达式变量中。此时虽然修改 lambda 表达式中的这些外部变量并不会真正影响到外部，我们却仍然无法修改它们。
例如：

	int Num1 = 1;
	auto func3 = [&Num1]{
		cout << Num1 <<endl;
	};
	Num1 += 1;
	func3();
1
2
3
4
5
6

如果lambda 表达式没有捕获变量，则该lambda 表达式可以直接转换为函数指针，而捕获变量的 lambda 表达式则不能转换为函数指针。示例：

    typedef void(*fPtr)(int*);
    fPtr fp = [](int* p){delete p;};  // 正确，没有状态的lambda（没有捕获）的lambda表达式可以直接转换为函数指针
    fPtr fp1 = [&](int* p){delete p;};  // 错误，有状态的lambda不能直接转换为函数指针
1
2
3

• lambda表达式的类型
  C++11 中被称为“闭包类型（Closure Type）”。它是一个特殊的，匿名的非 nunion 的类类型。
  因此，我们可以认为它是一个带有 operator() 的类，即仿函数。因此，我们可以使用 std::function 和 std::bind 来存储和操作 lambda 表达式：

    std::function<int(int)>  f1 = [](int a){ return a; };
    std::function<int(void)> f2 = std::bind([](int a){ return a; }, 123);
1
2

对于没有捕获任何变量的 lambda 表达式，还可以被转换成一个普通的函数指针：

    using func_t = int(*)(int);
    func_t f = [](int a){ return a; };
    f(123);
1
2
3

捕获列表捕获住的任何外部变量，最终均会变为闭包类型的成员变量。而一个使用了成员变量的类的 operator()，如果能直接被转换为普通的函数指针，那么 lambda 表达式本身的 this 指针就丢失掉了。而没有捕获任何外部变量的 lambda 表达式则不存在这个问题，这也解释为何按值捕获无法修改捕获的外部变量，lambda 表达式的 operator() 默认是 const 的。一个 const 成员函数是无法修改成员变量的值的。而 mutable 的作用，就在于取消 operator() 的 const。

从上面我们知道按值捕获得到的外部变量值是在 lambda 表达式定义时的值。此时所有外部变量均被复制了一份存储在 lambda 表达式变量中。此时虽然修改 lambda 表达式中的这些外部变量并不会真正影响到外部，我们却仍然无法修改它们。
那么如果希望去修改按值捕获的外部变量应当怎么办呢？这时，需要显式指明 lambda 表达式为 mutable：

    int a = 0;
    //auto f1 = [=]{ return a++; };             // error，修改按值捕获的外部变量
    auto f2 = [=]() mutable { return a++; };  // OK，mutable
1
2
3

一个应用场景的例子：

#include 
#include 
#include 
using namespace std;
void func(void)
{
    vector<int> v = { 1, 2, 3, 4, 5, 6 };
    int even_count = 0;
    for_each( v.begin(), v.end(), [&even_count](int val)
            {
                if (!(val & 1))  // val % 2 == 0
                {
                    ++ even_count;
                }
            });
   	cout << "The number of even is " << even_count << endl;
    }
    int main(void)
    {
	    func();
	    return 0;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

示例代码

#include 
#include 
#include 



using namespace std;

class Person{
public:
	Person(){}
	Person(string nam,int ag)
	{
		this->name = nam;
		this->age = ag;
	}
	string name;
	int age;
};



void test01(void)
{
	auto func1 = []{
	cout << "hello world" << endl;
	};
	func1();
	auto add = [](int a,int b){
		return a+b;
	};
	cout << "a+b = " << add(1,2)<<endl;

	Person p1("Lihua",22);
	auto func2 = [&p1]{
		cout <<"name: "<<  p1.name << "  age: " << p1.age << endl;
	};
	func2();
	int Num1 = 1;
	auto func3 = [&Num1]{
		cout << Num1 <<endl;
		Num1 += 1;
	};
	Num1 += 1;
	func3();
	cout << Num1 << endl;


}

class temp
{
    public:
    int tmp = 0;
    void func(int a, int b)
    {
        // auto x1 = []{ 
		// 	return tmp; 
        // }; // error，没有捕获外部变量
        auto x2 = [=]{ 
			return tmp + a + b; 
        }; // OK，捕获所有外部变量
        auto x3 = [&]{ 
			return tmp + a + b; 
		}; // OK，捕获所有外部变量
        auto x4 = [this]{ 
			return tmp; 
		}; // OK，捕获this指针
        // auto x5 = [this]{ 
		// 	return tmp + a + b; 
		// }; // error，没有捕获x、y
        auto x6 = [this, a, b]{ 
			return tmp + a + b; 
		}; // OK，捕获this指针、x、y
        auto x7 = [this]{ 
			return tmp++; 
		}; // OK，捕获this指针，并修改成员的值
    }
};
void test02(void)
{

	auto a = 0, b = 1;
	// auto f1 = []{
	// 	return a; 
	// };  // error，没有捕获外部变量
	auto f2 = [&]{ 
		return a++; 
	};  // OK，捕获所有外部变量，并对a执行自加运算
	auto f3 = [=]{ 
		return a; 
	};  // OK，捕获所有外部变量，并返回a
	// auto f4 = [=]{ 
	// 	return a++; 
	// };  // error，a是以复制方式捕获的，无法修改
	// auto f5 = [a]{ 
	// 	return a + b; 
	// };  // error，没有捕获变量b
	auto f6 = [a, &b]{ 
		return a + (b++); 
	};  // OK，捕获a和b的引用，并对b做自加运算
	auto f7 = [=, &b]{ 
		return a + (b++); 
	};  // OK，捕获所有外部变量和b的引用，并对b做自加运算
}
int main(void)
{
	test01();
	test02();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

参考博文