C++ lambda表达式

一、lambda表达式基本用法

1、语法

Lambda 表达式的基本语法如下：
捕获列表 mutable(可选) 异常属性 -> 返回类型
{
// 函数体
}

2、lambda值捕获

/**
 * @brief lamdba值捕获
 */
void test()
{
	int nvalue = 1;
	auto func_copyvalue = [nvalue]
	{
		return nvalue;
	};
	nvalue = 100;
	auto nValue = func_copyvalue();
	cout << "value:" << nValue << endl;
	// 这时, nValue == 1, 而 nvalue == 100.
	// 因为 func_copyvalue 在创建时就保存了一份 nvalue 的拷贝
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3、lambda引用捕获

/**
 * @brief lamdba值捕获
 */
void test()
{
	int nvalue = 1;
	auto func_copyvalue = [&nvalue]
	{
		return nvalue;
	};
	nvalue = 100;
	auto nValue = func_copyvalue();
	cout << "value:" << nValue << endl;
	// 这时, nValue == 100, 而 nvalue == 100.
	// 因为 func_copyvalue 保存的是引用
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4、lambda隐式捕获

/*
[] 空捕获列表
[name1, name2, ...] 捕获一系列变量
[&] 引用捕获, 让编译器自行推导引用列表
[=] 值捕获, 让编译器自行推导值捕获列表
*/
void test()
{
	// [] 空捕获列表
	auto func1 = [](int a) {return a; };

	// [name1, name2, ...] 捕获一系列变量
	int name1 = 1;
	int name2 = 2;
	int name3 = 3;
	auto func2 = [name1, name2, name3]() {return name1 + name2 + name3; };

	// [&] 引用捕获, 让编译器自行推导引用列表
	auto func3 = [&]() {return name1 + func1(1); };

	// [=] 值捕获, 让编译器自行推导值捕获列表
	auto func4 = [=]() {return name1; };
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

5、lambda表达式捕获

上面提到的值捕获、引用捕获都是已经在外层作用域声明的变量，因此这些捕获方式捕获的均为左值，而不能捕获右值。
C++14 给与了我们方便，允许捕获的成员用任意的表达式进行初始化，这就允许了右值的捕获， 被声明的捕获变量类型会根据表达式进行判断，判断方式与使用 auto 本质上是相同的

#include 
#include 
void test()
{
	auto important = std::make_unique<int>(1);
	auto add = [v1 = 1, v2 = std::move(important)](int x, int y)->int
	{
		return x + y + v1 + (*v2);
	};
	cout << add(3, 4) << endl;
}
1
2
3
4
5
6
7
8
9
10
11

6、泛型lambda

void test()
{
	auto add = [](auto x, auto y) {return x + y; };
	cout << add(3, 4) << endl;
	cout << add(1, 2) << endl;
	cout << add(1.1, 2.3) << endl;
}
1
2
3
4
5
6
7

二、lambda表达式与algorithm相结合使用(记录常用的)

1、std::sort

#include 
#include 
void test()
{
    std::vector<int> vec{1,3,5,2,4,7,9,8,10};
    std::sort(vec.begin(),vec.end(),
        [](int a, int b)
        {
            return a < b;
        });
}
1
2
3
4
5
6
7
8
9
10
11

2、std::for_each

#include 
#include 
void test()
{
    std::vector<int> vecTest{1,3,5,2,4,7,9,8,10};
    std::for_each(vecTest.begin(), vecTest.end(), 
        [](int n) 
        { 
            return n; 
        });
}
1
2
3
4
5
6
7
8
9
10
11

3、std::copy

#include 
#include 
void test()
{
    std::vector<int> m_Vec{1,3,5,2,4,7,9,8,10};
    std::copy(m_Vec.begin(), m_Vec.end(), ostream_iterator<int>(cout, " "));
}
1
2
3
4
5
6
7

4、std::function

#include 
#include 
#include 
void test()
{
    std::map<std::string, std::function<int(int, int)>> op_dict = 
    {
        {"+", [](int x, int y)
              {
                      return x + y;
              }
        },
        {"-", [](int x, int y)
              {
                      return x - y;
              }
        },
        {"*", [](int x, int y)
              {
                      return x * y;
              }
        },
        {"/", [](int x, int y)
              {
                      return x / y;
              }
        },
    };
}
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

5、std::find_if

#include 
#include 
void test()
{
    std::vector<int> vec{ 1,2,3,5,3,7,9,5,10 };
    auto iter = std::find_if(vec.begin(), vec.end(),
        [](int a)
        {
            return a > 5;
        });
}
1
2
3
4
5
6
7
8
9
10
11

6、std::count_if

#include 
#include 
void test()
{
    std::vector<int> vec{ 1,2,3,5,3,7,9,5,10 };
    auto iter = std::count_if(vec.begin(), vec.end(),
        [](int a)
        {
            return a > 5;
        });
}
1
2
3
4
5
6
7
8
9
10
11

三、lambda在线程中使用

#include 
#include 

using namespace std;

int main() 
{
    std::thread tthread001(
    [](int x)
    {
    	cout << x << endl;
    }
    , 100);
    tthread001.join();
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16