C++ 11 & 14 中的Lambda表达式 补充

对于每个 lambda，它都是一个独一无二的匿名的类型。
仿函数、lambda 哪怕能像函数一样使用，但也不是函数类型！另外还要注意一点，函数不是函数指针类型！
lambda 本质上就是个重载了小括号运算符的匿名结构体的对象。

所以捕获列表为空时，相当于一个空结构体，只有一个入口地址信息，类型转换成函数指针当然没问题。
而有捕获时，就“拖家带口”了，这个 lambda 除了有入口地址以外，还携带了它所捕获的外部变量。而函数指针只能和“入口地址”对等，这就导致函数指针只能接受一个入口地址，不能接受额外的信息了，所以当然不可以隐式转换为函数指针。

对于每个 lambda，它都是一个独一无二的匿名的类型。

#include 
using namespace std;

int main()
{
    auto f1 = [](){};
    auto f2 = [](){};
    cout << typeid(f1).name() << endl;
    cout << typeid(f2).name() << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11

 g++ .\lam2.cpp -o lam2     
.\lam2.exe
Z4mainEUlvE_ 
Z4mainEUlvE0_
1
2
3
4

lambda 本质上就是个重载了小括号运算符的匿名结构体的对象。

#include 
#include 

struct predict
{
	int x;
	
	predict(int x) : x(x) {}
	
	bool operator()(int e) const
	{
		return e == x;
	}
};

int main()
{
	int a[] = {1, 2, 3, 4, 5, 6, 7};
	int x = 4;

    // C++11 仿函数以前是这么干的 
	predict p(x);
	int * pos2 = std::find_if(a, a + 7, p);
    std::cout << *pos2 << std::endl;
	std::cout << pos2 - a << std::endl;
	
	// C++11 有 lambda 了 
	int * pos2 = std::find_if(a, a + 7, [x](int e) {
		return e == x;
	});
    std::cout << *pos2 << std::endl;
	std::cout << pos2 - a << std::endl;
}
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

函数类型：

仿函数、lambda 哪怕能像函数一样使用，但也不是函数类型！另外还要注意一点，函数不是函数指针类型！

为什么 []() {} 、[=]() {}、[&]() {} 不是同一个类型?

因为不能说它们有相同的参数列表、有相同的返回类型，它们 lambda 就是同一个类型了。
它们有着不同的捕获列表。在编译器眼里，lambda 其实就是个跟仿函数一样的东西。

struct {
 int x;
 bool operator()(int e) const;
};
1
2
3
4

还有

struct {
 int x;
 double y;
 bool operator()(int e) const;
};
1
2
3
4
5

还有

struct {
 int & x;
 bool operator()(int e) const;
};
1
2
3
4

这些连数据成员都不一样的结构体都搞成同一个类型啊？就因为它们都有一样的 bool operator()(int e) const; 吗？
面向对象告诉你，这叫它们都实现了同样的接口，不叫它们是同一个类型。
至于为什么捕获列表都一样了还是不同类型，就是强行规定了。
每个 lambda 都是不同的类型，哪怕它们一样