• C++11——包装器与lambda表达式

    目录

    一.背景

    二.lambda

    1.见一见lambda

    2.lambda表达式语法

    3.lambda捕捉列表说明

    三.函数对象与lambda表达式

    四.包装器

    1.function包装器

    2.包装类的成员函数

     五.bind

    1.调整参数位置

    2.减少函数参数

    一.背景

    在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法。

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. void Print(vector<int>& arr)
    6. {
    7. 	for (auto e : arr)
    8. 	{
    9. 		cout << e << " ";
    10. 	}
    11. 	cout << endl;
    12. }
    13.  
    14. int main()
    15. {
    16. 	vector<int> arr = { 4,1,8,5,3,7,0,9,2,6 };
    17.  
    18. 	//降序
    19. 	sort(arr.begin(), arr.end(),greater<int>());
    20. 	Print(arr);
    21. 	//升序
    22. 	sort(arr.begin(), arr.end());
    23. 	Print(arr);
    24.  
    25. 	return 0;
    26. }

    如果待排序元素为自定义类型，需要用户定义排序时的比较规则：

    1. struct Goods
    2. {
    3. 	string _name;  //名字
    4. 	double _price; //价格
    5. 	int _evaluate; //评价
    6. 	Goods(const char* str, double price, int evaluate)
    7. 		:_name(str)
    8. 		, _price(price)
    9. 		, _evaluate(evaluate)
    10. 	{}
    11. };
    12. struct ComparePriceLess
    13. {
    14. 	bool operator()(const Goods& gl, const Goods& gr)
    15. 	{
    16. 		return gl._price < gr._price;
    17. 	}
    18. };
    19. struct ComparePriceGreater
    20. {
    21. 	bool operator()(const Goods& gl, const Goods& gr)
    22. 	{
    23. 		return gl._price > gr._price;
    24. 	}
    25. };
    26.  
    27. void Print(vector& v)
    28. {
    29. 	for (auto e : v)
    30. 	{
    31. 		cout << e._name << ":" << e._price << ":" << e._evaluate << endl;
    32. 	}
    33. 	cout << endl;
    34. }
    35. int main()
    36. {
    37. 	vector v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,3 }, { "菠萝", 1.5, 4 } };
    38. 	sort(v.begin(), v.end(), ComparePriceLess());
    39. 	Print(v);
    40. 	sort(v.begin(), v.end(), ComparePriceGreater());
    41. 	Print(v);
    42. 	return 0;
    43. }

    随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法，
    都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，
    这些都给编程者带来了极大的不便。    因此，在C++11语法中出现了Lambda表达式。

    二.lambda

    1.见一见lambda

    改装上面的代码：

    1. struct Goods
    2. {
    3. 	string _name;  //名字
    4. 	double _price; //价格
    5. 	int _evaluate; //评价
    6. 	Goods(const char* str, double price, int evaluate)
    7. 		:_name(str)
    8. 		, _price(price)
    9. 		, _evaluate(evaluate)
    10. 	{}
    11. };
    12.  
    13. void Print(vector& v)
    14. {
    15. 	for (auto e : v)
    16. 	{
    17. 		cout << e._name << ":" << e._price << ":" << e._evaluate << endl;
    18. 	}
    19. 	cout << endl;
    20. }
    21. int main()
    22. {
    23. 	vector v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,3 }, { "菠萝", 1.5, 4 } };
    24. 	sort(v.begin(), v.end(), [](const Goods g1, const Goods g2)->bool {return g1._price < g2._price; });
    25. 	Print(v);
    26. 	sort(v.begin(), v.end(), [](const Goods g1, const Goods g2)->bool {return g1._price > g2._price; });
    27. 	Print(v);
    28. 	return 0;
    29. }

    上述代码就是使用C++11中的lambda表达式来解决，可以看出lambda表达式实际是一个匿名函
    数。

    2.lambda表达式语法

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

    [capture-list] :

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

    1. int main()
    2. {
    3. 	int a = 100;
    4. 	int b = 200;
    5. 	int sum = 0;
    6. 	auto lam = [a, b]()->int {return a + b; };
    7. 	sum = lam();
    8. 	cout << "a + b = "<
    9. 	return 0;
    10. }

    (parameters)：

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

    1. int main()
    2. {
    3. 	int a = 100;
    4. 	int b = 200;
    5. 	int sum = 0;
    6. 	auto lam = [](int a,int b)->int {return a + b; };
    7. 	sum = lam(a,b);
    8. 	cout << "a + b = "<
    9. 	return 0;
    10. }

    mutable：

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

     默认对捕捉的变量有const属性：

    1. int main()
    2. {
    3. 	int a = 100;
    4. 	int b = 200;
    5. 	int sum = 0;
    6. 	auto lam = [a,b]()
    7. 	{
    8. 		a = b = 50;
    9. 		cout << "a:" << a << endl;
    10. 		cout << "b:" << b << endl;
    11. 	};
    12. 	lam();
    13. 	cout << "a:" << a << endl;
    14. 	cout << "b:" << b << endl;
    15. 	
    16. 	return 0;
    17. }

     加上mutable关键字：

    注意：

    1. 使得lambda捕捉的变量失去const属性，但是不说变量的修改的范围仅限于lambda表达式的内部。
    2. 在lambda的外部数据仍旧是外部的值。

    ->returntype：

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

    {statement}：

    函数体，在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。

    通过上述例子可以看出，lambda表达式实际上可以理解为无名函数，该函数无法直接调
    用，如果想要直接调用，可借助auto将其赋值给一个变量。     

    3.lambda捕捉列表说明

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

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

    1. int main()
    2. {
    3. 	int a = 100;
    4. 	int b = 200;
    5. 	int sum = 0;
    6. 	auto lam1 = [a]()
    7. 	{
    8. 		cout << a << endl;
    9. 	};
    10. 	lam1();
    11.  
    12. 	return 0;
    13. }

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

    1. int main()
    2. {
    3. 	int a = 100;
    4. 	int b = 200;
    5. 	int sum = 0;
    6. 	auto lam1 = [=]()
    7. 	{
    8. 		cout << a << endl;
    9. 		cout << b << endl;
    10. 	};
    11. 	lam1();
    12. 	return 0;
    13. }

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

    1. int main()
    2. {
    3. 	int a = 100;
    4. 	int b = 200;
    5. 	int sum = 0;
    6. 	auto lam1 = [&a]()
    7. 	{
    8. 		a = 500;
    9. 	};
    10. 	lam1();
    11. 	cout << "a:" << a;
    12. 	return 0;
    13. }

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

    1. int main()
    2. {
    3. 	int a = 100;
    4. 	int b = 200;
    5. 	int sum = 0;
    6. 	auto lam1 = [&]()
    7. 	{
    8. 		a = b = 50;
    9. 	};
    10. 	lam1();
    11. 	cout << "a:" << a << endl;
    12. 	cout << "b:" << b << endl;
    13. 	
    14. 	return 0;
    15. }

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

    1. class Test
    2. {
    3. public:
    4. 	Test(int a)
    5. 		:_a(a)
    6. 	{
    7. 	}
    8.  
    9. 	void operator()()
    10. 	{
    11. 		//捕捉this指针之后，无需使用this类指定成员，可以直接访问类成员
    12. 		auto Prin_a = [this]() {cout <<"class Teat::_a:" << _a << endl; };
    13. 		Prin_a();
    14. 	}
    15.  
    16. private:
    17. 	int _a;
    18. 	
    19. };
    20.  
    21. int main()
    22. {
    23. 	Test T(100);
    24. 	T();
    25. 	return 0;
    26. }

    注意： 捕捉this指针之后，无需使用this类指定成员，可以直接访问类成员。

    三.函数对象与lambda表达式

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

    1. class Rate
    2. {
    3. public:
    4. 	Rate(double rate) : _rate(rate)
    5. 	{}
    6. 	double operator()(double money, int year)
    7. 	{
    8. 		return money * _rate * year;
    9. 	}
    10. private:
    11. 	double _rate;
    12. };
    13. int main()
    14. {
    15. 	// 函数对象
    16. 	double rate = 0.49;
    17. 	Rate r1(rate);
    18. 	r1(10000, 2);
    19. 	// lamber
    20. 	auto r2 = [=](double monty, int year)->double {return monty * rate * year;
    21. 	};
    22. 	r2(10000, 2);
    23. 	return 0;
    24. }

    从使用方式上来看，函数对象与lambda表达式完全一样。
    函数对象将rate作为其成员变量，在定义对象时给出初始值即可，lambda表达式通过捕获列表可
    以直接将该变量捕获到。

    UUID 是 通用唯一识别码（Universally Unique Identifier）的缩写，是一种软件建构的标准，亦为开放软件基金会组织在分布式计算环境领域的一部分。其目的，是让分布式系统中的所有元素，都能有唯一的辨识信息，而不需要通过中央控制端来做辨识信息的指定。

    实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如
    果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。 

    四.包装器

    1.function包装器

    function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。那么我们来看看，我们为什么需要function呢？

    ret = func(x);

    上面func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能
    是lamber表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！为什么呢？我们继续往下看:

    1. template<class F, class T>
    2. T useF(F f, T x)
    3. {
    4. 	static int count = 0;
    5. 	cout << "count:" << ++count << endl;
    6. 	cout << "count:" << &count << endl;
    7. 	return f(x);
    8. }
    9. double f(double i)
    10. {
    11. 	return i / 2;
    12. }
    13. struct Functor
    14. {
    15. 	double operator()(double d)
    16. 	{
    17. 		return d / 3;
    18. 	}
    19. };
    20. int main()
    21. {
    22. 	// 函数名
    23. 	cout << useF(f, 11.11) << endl;
    24. 	// 函数对象
    25. 	cout << useF(Functor(), 11.11) << endl;
    26. 	// lamber表达式
    27. 	cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
    28. 	return 0;
    29. }

    通过上面的程序验证，我们会发现useF函数模板实例化了三份，产生这个的原因是，即使这三个可调用对象的功能都是一模一样的，但是由于三个可调用对象，一个是函数，一个是类对象，一个是lambda表达式，是三种不同的类型，所以也就导致了模板在实例化的时候，会实例化出三份useF函数。

    包装器可以很好的解决上面的问题：

    1. // 类模板原型如下
    2. template <class T> function;   // undefined
    3. template <class Ret, class... Args>
    4. class function<Ret(Args...)>;
    5. 模板参数说明：
    6. Ret: 被调用函数的返回类型
    7. Args…：被调用函数的形参

    包装上述可调用对象：

    1. #include
    2. template<class F, class T>
    3. T useF(F f, T x)
    4. {
    5. 	static int count = 0;
    6. 	cout << "count:" << ++count << endl;
    7. 	cout << "count:" << &count << endl;
    8. 	return f(x);
    9. }
    10. double f(double i)
    11. {
    12. 	return i / 2;
    13. }
    14. struct Functor
    15. {
    16. 	double operator()(double d)
    17. 	{
    18. 		return d / 3;
    19. 	}
    20. };
    21.  
    22. int main()
    23. {
    24. 	function<double(double)> func1 = f;
    25. 	function<double(double)> func2 = Functor();
    26. 	function<double(double)> func3 = [](double d) {return d / 1; };
    27. 	
    28. 	useFdouble(double)>, double>(func1, 11.11);
    29. 	useFdouble(double)>, double>(func2, 11.11);
    30. 	useFdouble(double)>, double>(func3, 11.11);
    31.  
    32. 	return 0;
    33. }

    2.包装类的成员函数

    对于类的成员函数，针对静态成员函数与普通函数几乎没有差异，针对类的普通成员函数，我们需要在包装的时候，传递一个类的对象，或者类的对象的指针。

    1. class Add
    2. {
    3. public:
    4. 	Add(int a)
    5. 		:_a(a)
    6. 	{}
    7. 	int add(int b)
    8. 	{
    9. 		return _a + b;
    10. 	}
    11. 	static int s_add(int a, int b)
    12. 	{
    13. 		return a + b;
    14. 	}
    15. private:
    16. 	int _a;
    17. };
    18.  
    19. int main()
    20. {
    21. 	//包装非静态成员函数,用对象构建
    22. 	function<int(Add, int)> fun1 = &Add::add;
    23. 	cout << fun1(Add(10), 30) << endl;
    24. 	
    25. 	//包装非静态成员函数，用对象指针构建
    26. 	Add add(10);
    27. 	function<int(Add*, int)> fun3 = &Add::add;
    28. 	cout << fun3(&add, 30) << endl;
    29.  
    30. 	//包装静态成员函数
    31. 	function<int(int,int)> fun2 = Add::s_add;
    32. 	cout << fun2(10, 30) << endl;
    33.  
    34. 	return 0;
    35. }

    注意：包装类的非静态成员函数，使用类对象的指针包装，就不能在调用的时候用匿名对象传参，因为只有左值才能取地址。

     五.bind

    std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。

    1. // 原型如下：
    2. template <class Fn, class... Args>
    3. /* unspecified */ bind (Fn&& fn, Args&&... args);
    4. // with return type (2)
    5. template <class Ret, class Fn, class... Args>
    6. /* unspecified */ bind (Fn&& fn, Args&&... args);

    可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对
    象来“适应”原对象的参数列表。
    调用bind的一般形式：

    auto newCallable = bind(callable,arg_list);

    其中，newCallable 本身是一个可调用对象，也可以使用函数对象接收，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中的参数。

    arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示
    newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对
    象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推。

    1.调整参数位置

    1. void Plus(int a, int b)
    2. {
    3. 	cout << a << " " << b << endl;
    4. }
    5.  
    6. int main()
    7. {
    8. 	//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
    9. 	function<void(int, int)> func1 = std::bind(Plus, placeholders::_1, placeholders::_2);
    10. 	func1(1, 2);
    11. 	
    12. 	//通过_2,_1代表的参数的位置
    13. 	function<void(int, int)> func2 = std::bind(Plus, placeholders::_2, placeholders::_1);
    14. 	func2(1, 2);
    15.  
    16. 	return 0;
    17. }

    2.减少函数参数

    通过指定一个位置的参数，在调用时少传一个参数。

    1.  class Add
    2. {
    3. public:
    4. 	Add(int c)
    5. 		:_c(c)
    6. 	{}
    7. 	int add(int a,int b)
    8. 	{
    9. 		return (a + b) * _c;
    10. 	}
    11. private:
    12. 	int _c;
    13. };
    14.  
    15. int main()
    16. {
    17. 	//包装非静态成员函数,用对象构建
    18. 	function<int(Add, int,int)> fun1 = &Add::add;
    19. 	cout << fun1(Add(10), 3,2) << endl;
    20.  
    21. 	//包装非静态成员函数,用对象构建
    22. 	//指定一个参数Add(10)作为参数，剩余参数正常传参
    23. 	function<int(int,int)> fun2 = bind(&Add::add, Add(10), placeholders::_1, placeholders::_2);
    24. 	cout << fun2(3,2) << endl;
    25. 	
    26. 	return 0;
    27. }

  • 相关阅读:
    Matlab学习-常用函数
    网络知识点之-MSTP平台
    【机器学习】为什么会产生过拟合，有哪些方法可以预防或克服过拟合？(面试回答)
    06-React的路由
    故障管理:鼓励做事，而不是处罚错误
    赛桨PaddleScience v1.0 Beta：基于飞桨核心框架的科学计算通用求解器
    【动手深度学习-笔记】注意力机制（一）注意力机制框架
    对于一个即将上线的网站，如何测试
    Go简单入门：添加测试
    信息学奥赛一本通 1353：表达式括号匹配(stack) | 洛谷 P1739 表达式括号匹配
  • 原文地址：https://blog.csdn.net/qq_63943454/article/details/133907518