C++11_lambda表达式

文章目录

一、lambda表达式
- 1.lambda的组成
- - [2.[capture-list] 的其他使用方法](#2.[capture-list] 的其他使用方法)
  - 2.1混合捕捉
二、lambda表达式的使用场景
- 1.替代仿函数
总结

一、lambda表达式

lambda表达式是C++11新引入的功能，它的用法与我们之前学过的C++语法有些不同。

1.lambda的组成

[capture-list] (parameters) mutable -> return-type { statement }
[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来

判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda

函数使用。

(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以

连同()一起省略

mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量

性。使用该修饰符时，参数列表不可省略(即使参数为空)。

->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推

导。

{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量
示例代码如下

cpp 复制代码

	int a = 2;
	int b = 3;
	auto func1 = [](int a, int b)->int {
		return a + b;
		};
	std::cout << func1(a, b) << std::endl;

首先看示例代码

"[capture-list]": 下面再讲，这里需要记住是[]即便里面没有内容也不可以省略。

"(parameters)" :很像我们函数的参数列表，而实际上在这里的作用也是如此。如果没有参数，那么可以连同()一起省略

"->returntype" :->返回值类型，一般都可以省略，但是推荐不省略。

"{}": 可以理解为函数体，内部写自己想实现的功能。

示例代码如下

cpp 复制代码

	int a = 2;
	int b = 3;
	auto func1 = [a, b]()->int {
		++a;  编译报错
		++b;  编译报错
		return a + b;
	};
	
	auto func2 = [a, b]()mutable->int {
		++a;   运行通过
		++b;
		return a + b;
	};
	func2(); //调用func2
	std::cout << " func2: " << a << " - " << b << std::endl;

"[capture-list]": 捕捉的是现有变量让它们能在函数体内运行。

func1 和 func2 唯一的区别就是有没有加mutable（可变的）。默认情况下，lambda函数总是一个const函数，mutable可以取消其常量

性。所以func2使用mutable就可以改变函数体内a和b的值。

那么这里提出疑问，外面的a和b的值是否被修改？ -> 不会

因为这里其实是一个传值拷贝，如果你需要在lambda内部改变外面的a，b，可以使用引用

cpp 复制代码

	int a = 2;
	int b = 3;
	
	auto func1 = [a, b]()mutable->int {
		++a;
		++b;
		return a + b;
		};
	func1（）; //调用func1
	std::cout << " func1: " << a << " - " << b << std::endl;

	auto func2 = [&a, &b]()mutable->int {
		++a;
		++b;
		return a + b;
		};
	func2（）; //调用func2
	std::cout << " func2: " << a << " - " << b << std::endl;

2.[capture-list] 的其他使用方法

"[=]":根据上下文全部以值传递捕捉变量

"[&]':根据上下文全部以引用传递捕捉变量

cpp 复制代码

	int a = 1;
	int b = 2;
	double d = 2.2;
	std::string str = "hello world";

	auto func1 = [=]()mutable {  //根据上下文全部以值传递捕捉变量
		std::cout << a << " " << b << " " << d << " " << str << std::endl;
		a = 10;
		};
	func1();
	std::cout << "a: " << a << std::endl << std::endl;;

	auto func2 = [&]()mutable {  //根据上下文全部以引用传递捕捉变量
		std::cout << a << " " << b << " " << d << " " << str << std::endl;
		a = 10;
		};
	func2();
	std::cout << "a: " << a << std::endl;

2.1混合捕捉

cpp 复制代码

	int a = 1;
	int b = 2;
	double d = 2.2;
	std::string str = "hello world";

	auto func1 = [= , &a]()mutable{//除a以引用传递捕捉，其他根据上下文全部以值传递捕捉变量
		std::cout << a << " " << b << " " << d << " " << str << std::endl;
		a = 10;
		};
	func1();
	std::cout << "a: " << a << std::endl << std::endl;;

	auto func2 = [&, a]()mutable{//除a以值传递捕捉，其他根据上下文全部以引用传递捕捉变量
		std::cout << a << " " << b << " " << d << " " << str << std::endl;
		a = 1;
		};
	func2();
	std::cout << "a: " << a << std::endl;

二、lambda表达式的使用场景

1.替代仿函数

仿函数我们之前对于实现很多STL中的容器的排序都使用过，应该不陌生，而lambda表达式我们看来其实也跟一个函数差不多，一样有参数，一样有返回值，一样能写函数体，所以我们就可以使用lambda来取代仿函数

cpp 复制代码

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<functional>
struct Goods {

	Goods(std::string name, double price, size_t evaluation)
		:_name(name)
		,_price(price)
		,_evaluation(evaluation) {}

	std::string _name;
	double _price;
	size_t _evaluation;
};

int main()
{
	std::vector<Goods> v = {{ "苹果", 2.1, 5 },{ "香蕉", 3, 4 }, 
						{ "橙子", 2.2, 3 },{ "菠萝",1.5,4 }};


	std::sort(v.begin(), v.end(), [](const Goods& s1, const Goods& s2)->bool {
	return s1._name < s2._name;
	}); // 字符串升序
	for (auto& a : v)
	{
		std::cout << a._name << " - " << a._price << " - " << 	a._evaluation << std::endl;
	}
	std::cout << std::endl;


	std::sort(v.begin(), v.end(), [](const Goods& s1, const Goods& s2)->bool {
	return s1._name > s2._name;
	}); // 字符串降序
	for (auto& a : v)
	{
		std::cout << a._name << " - " << a._price << " - " << a._evaluation << std::endl;
	}
	std::cout << std::endl;


	std::sort(v.begin(), v.end(), [](const Goods& s1, const Goods& s2)->bool {
	return s1._price < s2._price;
	}); // 价格升序
	for (auto& a : v)
	{
	std::cout << a._name << " - " << a._price << " - " << a._evaluation << std::endl;
	}
	std::cout << std::endl;


	std::sort(v.begin(), v.end(), [](const Goods& s1, const Goods& s2)->bool {
		return s1._evaluation < s2._evaluation;
		}); // 评价升序
	for (auto& a : v)
	{
		std::cout << a._name << " - " << a._price << " - " << a._evaluation << std::endl;
	}
	std::cout << std::endl;

	return 0;
}

总结

这些就是lambda表达式的全部内容，lambda表达式还是十分有用的，对于一些我们只需要运行一遍的函数或者是对象内传仿函数类型，我们都可以使用使用lambda表达式。