【C++11】lambda表达式&包装器

最新推荐文章于 2024-05-07 23:38:51 发布

meow_yao

最新推荐文章于 2024-05-07 23:38:51 发布

阅读量152

点赞数

文章标签： c++

本文链接：https://blog.csdn.net/weixin_60371270/article/details/131868690

版权

一、lambda表达式

1. lambda表达式的由来

C++98中便有了仿函数的定义，但是仿函数和函数指针的定义都比较麻烦，C++11增加了lambda表达式的定义。

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

2. lambda表达式的语法

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

[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。捕捉列表可以为空，但不可以省略。

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

mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。指明参数可变，不过lambda表达式的参数是实参的拷贝，即使加上mutable修饰，修改后的值也不会影响实参。故一般不用，但是一旦使用，则参数列表不可省略（仍可以为空）。

->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。（返回值可省略不写）故一般可不写，但写一下更方便，可读性更强。

{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。函数体可以为空，但不可省略。

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

3. 捕获列表说明

捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。

[var]：表示值传递方式捕捉变量var

[=]：表示值传递方式捕获所有父作用域中的变量(包括this)

[&var]：表示引用传递捕捉变量var

[&]：表示引用传递捕捉所有父作用域中的变量(包括this)

注：var指变量名。

[this]：表示值传递方式捕捉当前的this指针

注意：

a. 父作用域指包含lambda函数的语句块

b. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。

比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量

[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量

c. 捕捉列表不允许变量重复传递，否则就会导致编译错误。

比如：[=, a]：=已经以值传递方式捕捉了所有变量，重复捕捉a，会导致编译错误。

d. 在块作用域以外的lambda函数捕捉列表必须为空。

e. lambda表达式之间不能相互赋值，即使看起来类型相同。因为lambda表达式的底层本质上是仿函数，不同的lambda表达式即使内容相同，底层实现也是两个不同的类，故不能相互赋值。

4. 实例说明

如下，结合内置类型和自定义类型的排序进行仿函数和lambda表达式的使用说明：

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

//1. lambda表达式
//1.1函数 、仿函数、lambda表达式都可实现相同的功能
//lambda表达式比较简单（C++11）

//商品Goods类
struct Goods//struct定义的类默认成员属性为public（为了兼容C语言）
{
	string _name;  // 名字
	double _price; // 价格
	int _evaluate; // 评价(1 - 5)

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

// 仿函数实现排序逻辑
class GreaterByPrice//按价格的升序排列
{
public:
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._price < g2._price;
	}
};

class LessByPrice//按价格的降序排列
{
public:
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._price > g2._price;
	}
};

class GreaterByEvaluate//按评价的升序排列
{
public:
	bool operator()(const Goods& g1,const Goods& g2)
	{
		return g1._evaluate < g2._evaluate;
	}
};

class LessByEvaluate//按评价的降序排列
{
public:
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._evaluate > g2._evaluate;
	}
};

int main()
{
	//1. 用sort和仿函数实现数组升序、降序排列
	int array[] = { 4,1,8,5,3,7,0,9,2,6 };
	// 默认按照小于比较，排出来结果是升序
	sort(array, array + sizeof(array) / sizeof(array[0]));
	// 如果需要降序，需要改变元素的比较规则
	//greater是算法库中定义的仿函数，用于实现升序排列
	sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());

	//2. 如上，只适用于内置类型数据的比较，自定义类型需自己定义比较函数
	//以Goods类为例
	vector<Goods> gs = { {"洗衣液",20,4},{"沐浴露",29,3},{"胭脂",55,4},{"水粉",30,2} };
	//对gs按价格的升序排列
	sort(gs.begin(), gs.end(), GreaterByPrice());
	//对gs按评价的升序排列
	sort(gs.begin(), gs.end(), GreaterByEvaluate());

	//3.综上，仿函数在实现比较逻辑时比较麻烦(类的命名和实现)
	//用lambda表达式实现比较逻辑如下
	//价格升序
	sort(gs.begin(), gs.end(), [](const Goods& g1, const Goods& g2)->bool
		{return g1._price < g2._price;});
	//价格降序
	sort(gs.begin(), gs.end(), [](const Goods& g1, const Goods& g2)->bool
		{return g1._price > g2._price;});
	//评价升序
	sort(gs.begin(), gs.end(), [](const Goods& g1, const Goods& g2)->bool
		{return g1._evaluate < g2._evaluate;});
	//评价降序
	sort(gs.begin(), gs.end(), [](const Goods& g1, const Goods& g2)->bool
		{return g1._evaluate > g2._evaluate;});

	return 0;
}

如上，不难看出，lambda表达式实际是一个匿名函数（底层实现是仿函数）。

//1.2 lambda表达式的相关注意事项
int main()
{
    // 最简单的lambda表达式, 该lambda表达式没有任何意义
    [] {};

    // 省略参数列表和返回值类型，返回值类型由编译器推导为int
    int a = 3, b = 4;
    [=] {return a + 3; };

    // 省略了返回值类型，无返回值类型
    auto fun1 = [&](int c) {b = a + c; };
    fun1(10);
    cout << a << " " << b << endl;//3 13

    // 各部分都很完善的lambda函数
    auto fun2 = [=, &b](int c)->int {return b += a + c; };
    cout << fun2(10) << endl;//(13+10)+13=26

    // 赋值捕捉x
    int x = 10;
    auto add_x = [x](int a) mutable { x *= 2; return a + x; };
    cout << add_x(10) << endl;//10+20=30
    
    return 0;
}

二、包装器

1. function包装器

1.1本质&使用场景

function包装器也叫适配器。C++中的function本质是一个类模板，也是一个包装器。

包装器可以将对应的函数名、函数指针、函数对象、lambda表达式包装成同一种类型，从而使在实现类模板实例化时减少实例化的复杂度，本需实例化多份，但是function包装器进行包装后只需实例化一份，大大减少了编译器的工作量。

1.2实例说明

如下，结合实例进行说明：

未使用function包装器：

template<class F, class T>
T useF(F f, T x)
{
	static int count = 0;
	cout << "count:" << ++count << endl;
	cout << "count:" << &count << endl;
	return f(x);
}

//函数
double f(double i)
{
	return i / 2;
}

//仿函数
struct Functor
{
	double operator()(double d)
	{
		return d / 3;
	}
};

int main()
{
	// 函数名
	cout << useF(f, 11.11) << endl;
	// 函数对象
	cout << useF(Functor(), 11.11) << endl;
	// lambda表达式
	cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
	return 0;
}

如上可知，类模板实例化了三份。

使用function包装器后(返回值相同，参数相同，即可用同一个function包装器进行包装，模板实例化只需实例化一份)：

template<class F, class T>
T useF(F f, T x)
{
	static int count = 0;
	cout << "count:" << ++count << endl;//3
	cout << "count:" << &count << endl;

	return f(x);
}

double f(double i)
{
	return i / 2;
}

struct Functor
{
	double operator()(double d)
	{
		return d / 3;
	}
};

int main()
{
	// 函数名
	std::function<double(double)> func1 = f;
	cout << useF(func1, 11.11) << endl;
	// 函数对象
	std::function<double(double)> func2 = Functor();
	cout << useF(func2, 11.11) << endl;
	// lambda表达式
	std::function<double(double)> func3 = [](double d)->double { return d /
		4; };
	cout << useF(func3, 11.11) << endl;

	return 0;
}

具体使用场景可结合力扣https://leetcode.cn/problems/evaluate-reverse-polish-notation/进行学习和理解。

2. 绑定

std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。使用std::bind函数还可以实现参数个数调整或参数顺序调整等操作。

调用bind的一般形式：auto newCallable = bind(callable,arg_list);

其中，callable是一个可调用对象；arg_list是生成的新的可调用对象的参数列表——当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中的参数。

常用的有placeholder_n（占位符），表示传入的参数的顺序，例如：placeholder_2表示传入的第二个参数。

#include <iostream>
#include <functional>
using namespace std;

int Plus(int a, int b)
{
	return a + b;
}

class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};

int main()
{
	//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
	std::function<int(int, int)> func1 = std::bind(Plus, placeholders::_1,
		placeholders::_2);
	//auto func1 = std::bind(Plus, placeholders::_1, placeholders::_2);

	//func2的类型为 function<int(int, int)> 与func1类型一样
	//表示绑定函数 plus 的第一，二为： 1， 2
	auto  func2 = std::bind(Plus, 1, 2);
	cout << func1(1, 2) << endl;//3
	cout << func2() << endl;//3

	Sub s;
	// 绑定成员函数
	std::function<int(int, int)> func3 = std::bind(&Sub::sub, s,
		placeholders::_1, placeholders::_2);
	// 参数调换顺序
	std::function<int(int, int)> func4 = std::bind(&Sub::sub, s,
			placeholders::_2, placeholders::_1);
	cout << func3(1, 2) << endl;//-1
	cout << func4(1, 2) << endl;//1
	return 0;
}

说明：

调用func1时会将第一二个参数依次传给Plus并调用Plus函数；

调用func2时会将1和2依次传给Plus并调用Plus函数；

调用func3时会将第一二个参数依次传给&Sub::sub并调用sub函数，故func3(1, 2) = sub(1, 2) = -1；

调用func4会将第二个和第一个参数分别传给&Sub::sub的第一个和第二个参数并调用sub函数，故func4(1, 2) = sub(2, 1) = 1。

运行结果如下图：