c++11~c++20 -07-使用lambda注意点

关于lambda如何使用这里就不细说了，想了解的可以看看我另一篇基础文章c++ lambda

一、特殊的捕获方法

a.[this]----捕获this指针，捕获this指针可以让我们使用this类型的成员变量和函数。
b.[=]—捕获lambda表达式作用域的全部全量的值，包括this
c.[&]—捕获lambda表达式定义作用域的全部变量的引用，包括this.

接下来看看捕获this的示例，其余的同学们可以自己试一试。

#include
using namespace std;

class A
{
public:
	void test()
	{

		auto foo = [this]() {
			print();
			m_x = 5;
			cout << m_x << endl;

		};
		
		foo();
	}
private:
	void print()
	{
		cout << "this is print function\n";
	}
private:
	int m_x;

};

int main()
{
	A a;
	a.test();
	
	system("pause");
	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

结果：

二、广义捕获

C++14 标准中定义了广义捕获，所谓广义捕获实际上是两种捕获方式

• a.简单捕获，也是我们常规的捕获方法，既[identifier]、[&identifier]以及[this]等。
• b.初始化捕获，c++14引入。该方法解决了只能捕获lambda表达式定义的上下文的变量，而无法捕获表达式结果，以及自定义捕获变量名的问题。

示例：

int main()
{
	int x = 5;
	auto foo = [r = x + 1](){return r; };
	int y = foo();
	cout << y << endl;
	
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10

以上代码在c++14之前是无法通过编译的，因为c++11之支持简单捕获。很显然这里的r只存在于lambda表达式，如果此时在lambda表达式函数体使用变量x,则会出现编译错误。初始化捕获在某些场景下是非常实用的。比如异步调用时赋值this对象，防止lambda表达式调用时因原始this对象被析构造成未定义的行为。

class work
{
private:
	int m_nvalue;
public:
	work():m_nvalue(2022){}

	std::future<int> spawn()
	{
		return std::async([=]()->int {return m_nvalue; });
	}
};

std::future<int> foo()
{
	work tmp;
	return tmp.spawn();
}

int main()
{
	std::future<int> f = foo();
	cout << f.get() << endl;
	system("pause");
	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

结果：

这里我们期待f.get()返回的结果是2022，而实际上放回的却是-1047110685，这就是一个未定义行为，造成了程序的计算错误。接下来简单修改一下：

std::future<int> spawn()
{
	return std::async([=,tmp = *this]()->int {return tmp.m_nvalue; });
}
1
2
3
4

结果为：2022
上述代码使用了初始捕获，将*this复制到tmp对象中，然后再函数体内返回tmp对象的value.

三、C++17中对于lambda表达式的增强

C++17对lambda表达式有两处增强：

• a.常量表达式，主要体现在constexpr关键字上。
• b.对捕获this的增强。
  这里主要说一下this的增强，具体来说就是再捕获列表中直接添加[*this]，然后再lambda表达式函数体内直接使用this指向对象的成员，还是以前面的work类为例：

class work
{
private:
	int m_nvalue;
public:
	work():m_nvalue(2022){}

	std::future<int> spawn()
	{
		return std::async([*this]()->int {return m_nvalue; });
	}
};
1
2
3
4
5
6
7
8
9
10
11
12

结果：

上面的代码没有再使用tmp = this来初始化捕获列表，而是直接使用this，从结果可以看出[this]的语法让程序生成了一个this的副本，并存储于lambda表达式内。