【C++11特性篇】lambda表达式玩法全解

前言

大家好吖，欢迎来到 YY 滴C++系列 ，热烈欢迎！ 本章主要内容面向接触过C++的老铁
主要内容含：

欢迎订阅 YY滴C++专栏！更多干货持续更新！以下是传送门！

一.lambda解决个性化排序问题

[1]设计商品结构体

• 设计一个商品结构体如下所示

struct Goods
{
    string _name;  // 名字
    double _price; // 价格
    int _evaluate; // 评价

    Goods(const char* str, double price, int evaluate)
        :_name(str)
        , _price(price)
        , _evaluate(evaluate)
    {}
};

[2]利用仿函数（函数对象）解决个性化排序一览

• 如下所示，利用sort函数+仿函数可以实现不同的个性化排序
• 价格排大，价格排小，名字排大，名字排小…

//struct ComparePriceLess
struct Compare1
{
    bool operator()(const Goods& gl, const Goods& gr)
    {
        return gl._price < gr._price;
    }
};

//struct ComparePriceGreater
struct Compare2
{
    bool operator()(const Goods& gl, const Goods& gr)
    {
        return gl._price > gr._price;
    }
};

struct CompareEvaluateGreater
{
    bool operator()(const Goods& gl, const Goods& gr)
    {
        return gl._evaluate > gr._evaluate;
    }
};

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

	//sort(v.begin(), v.end(), Compare1());  // 价格升序

	//sort(v.begin(), v.end(), Compare2());  // 价格降序

	//sort(v.begin(), v.end(), CompareEvaluateGreater());  // 评价的降序

	sort(v.begin(), v.end(), Compare1()); 
	sort(v.begin(), v.end(), Compare2());

	return 0;
}

[3]利用lambda解决个性化排序一览

为什么要引入lambda？

• 我们可以观察[2]中用仿函数解决个性化排序会出现一个问题
• 我们如果看到CompareEvaluateGreater()这个仿函数，我们能知道它是根据"评价的降序"来进行排序
• 但是当我们看到Compare1()/Compare2()，我们并不能很直观知道它是根据什么来排序，需要找到该函数才明白

• 以下是改造成lambda形式的基本使用
• 具体详细的介绍部分在本篇博客的板块二中，这里展示基本使用方法[捕捉列表] (参数列表) mutable -> 返回值类型 { 函数体 }
• 首先我们要知道，lamda其实是一个局部的匿名函数对象，常与auto搭配使用

   //[捕捉列表] (参数列表) mutable -> 返回值类型 { 函数体 }
	// 局部的匿名函数对象
	auto less = [](int x, int y)->bool {return x < y; };
	cout << less(1, 2) << endl;

• 以下是改造成lambda形式的个性化排序

int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
	sort(v.begin(), v.end(), Compare1());
	sort(v.begin(), v.end(), Compare2());

	//auto goodsPriceLess = [](const Goods& x, const Goods& y)->bool {return x._price < y._price; };
	//                                                 没有返回值时此部分可省略
	auto goodsPriceLess = [](const Goods& x, const Goods& y){return x._price < y._price; };
	cout << goodsPriceLess(v[0], v[1]) << endl;
	sort(v.begin(), v.end(), goodsPriceLess);


	sort(v.begin(), v.end(), [](const Goods& x, const Goods& y) {
		return x._price < y._price; });

	sort(v.begin(), v.end(), [](const Goods& x, const Goods& y) {
		return x._price > y._price;});

	sort(v.begin(), v.end(), [](const Goods& x, const Goods& y) {
		return x._evaluate < y._evaluate;});

	sort(v.begin(), v.end(), [](const Goods& x, const Goods& y) {
		return x._evaluate > y._evaluate;});

	return 0;
}

二.lambda表达式语法

1）lambda表达式总览

lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement }

1. lambda表达式各部分说明
   [capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。

• (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略
• mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
• ->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
• {statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。

• 在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。

2) lambda的返回值类型一般可以省略

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

int main()
{
	int a = 0, b = 2;
	double rate = 2.555;
	auto add1 = [](int x, int y)->int {return x + y; };
	auto add2 = [](int x, int y) {return x + y; };//返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
}

3) 捕捉列表能够捕捉上下文中的变量供lambda函数使用

• 下面代码需要捕捉rate变量给后面函数体用

auto add3 = [rate](int x, int y) {return (x + y)* rate; };

4) 捕捉列表【特殊使用方式】一览

• [var]：表示值传递方式捕捉变量var
• [=]：表示值传递方式捕获所有父作用域中的变量(包括this)
• [&var]：表示引用传递捕捉变量var
• [&]：表示引用传递捕捉所有父作用域中的变量(包括this)
• [this]：表示值传递方式捕捉当前的this指针

• 以下为 [&] 演示+ [&,a] 演示

int a = 0;
int b = 1;
int c = 2;
int d = 3;
const int e = 1;
cout << &e << endl;

// 引用的方式捕捉所有对象，除了a
// a用传值的方式捕捉

//捕捉所有对象auto func = [&]{函数体}；
auto func = [&, a] {
	//a++;fail
	b++;
	c++;
	d++;
	//e++;
	cout << &e << endl;

5) mutable在【传值传参】时的用法

• 默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)

//这里程序是会报错的，可以这样理解：因为其参数默认是带const的，不能被修改
int x = 0, y = 2;
auto swap1 = [add1](int& x, int& y) {
	int tmp = x;
	x = y;
	y = tmp;

	cout << add1(x, y) << endl;
};
swap1(a, b);

int x = 0, y = 2;
auto swap1 = [x, y]() mutable {
	// mutable让捕捉的x和y可以改变了，
	// 但是他们依旧是外面x和y的拷贝
		int tmp = x;
		x = y;
		y = tmp;
	};
	swap1();

6)lambda在实现交换函数swap()时常用【传引用传参】而不是【传值传参+mutable】

• 在小点4中，我们是用下面代码实现swap()

int x = 0, y = 2;
auto swap1 = [x, y]() mutable {
	// mutable让捕捉的x和y可以改变了，
	// 但是他们依旧是外面x和y的拷贝
		int tmp = x;
		x = y;
		y = tmp;
	};
	swap1();

• 但是这一回略显繁琐，我们一般用【传引用传参】而不是【传值传参+mutable】，如下所示：

// 引用的方式捕捉
	int x = 0, y = 2;
	auto swap2 = [&x, &y](){
		int tmp = x;
		x = y;
		y = tmp;
	};
	swap2();

三.仿函数(函数对象)与【lambda表达式】的底层其实是一样的

[1]仿函数(函数对象)基本知识回顾

• 函数对象，又称为仿函数，即可以像函数一样使用的对象，就是在类中重载了operator()运算符的类对象

class Rate
{
public:
    Rate(double rate) : _rate(rate)
    {}
    double operator()(double money, int year)
    {
        return money * _rate * year;
    }
private:
    double _rate;
};

int main()
{
    // 函数对象
    double rate = 0.49;
    Rate r1(rate);
    r1(10000, 2);
    
    // lambda
    //[=]：表示值传递方式捕获所有父作用域中的变量(包括this)
    auto r2 = [=](double monty, int year)->double {return monty * rate * year;
    };
    r2(10000, 2);
    return 0;
}

[2]如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()

• 我们通过反汇编可以发现，底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的
• 也就是说：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()