• C++11 -------- lambda表达式

    目录

    1.lambda表达式的引出

    2.lambda表达式语法

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

    (1)参数说明

    (2)捕获列表说明

    3.lambda表达式的使用及注意事项

    (1)参数列表引用传参 交换数据

    (2)利用捕捉列表进行捕捉交换数据

    (3)传值方式捕捉(临时变量),达不到交换数据的目的 

    4.lambda表达式底层原理 

    (1)函数对象和lambda表达式的比较

    (2)查看底层汇编

    (3)本质就是因为lambda表达式在底层被转换成了仿函数

    (4)lambda表达式之间不能相互赋值 

    5.可调用对象

     

    1.lambda表达式的引出

    • C++98中的一个例子

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

    1. #include 
    2. #include 
    3.  
    4. int main()
    5. {
    6. int array[] = {4,1,8,5,3,7,0,9,2,6};
    7.  
    8. // 默认按照小于比较，排出来结果是升序
    9. std::sort(array, array+sizeof(array)/sizeof(array[0]));
    10.  
    11. // 如果需要降序，需要改变元素的比较规则
    12. std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());
    13.  
    14. return 0; 
    15. }

                     

    ②如果待排序元素为自定义类型，需要用户定义排序时的比较规则,这里传入仿函数来指定排序时的比较方式

    1. struct Goods
    2. {
    3. 	string _name;  //名字
    4. 	double _price; //价格
    5. 	int _evaluate; //评价
    6. };
    7.  
    8. struct ComparePriceLess
    9. {
    10. 	bool operator()(const Goods& g1, const Goods& g2)
    11. 	{
    12. 		return g1._price < g2._price;
    13. 	}
    14. };
    15.  
    16. struct ComparePriceGreater
    17. {
    18. 	bool operator()(const Goods& g1, const Goods& g2)
    19. 	{
    20. 		return g1._price > g2._price;
    21. 	}
    22. };
    23.  
    24. struct CompareEvaluateLess
    25. {
    26. 	bool operator()(const Goods& g1, const Goods& g2)
    27. 	{
    28. 		return g1._evaluate < g2._evaluate;
    29. 	}
    30. };
    31.  
    32. struct CompareEvaluateGreater
    33. {
    34. 	bool operator()(const Goods& g1, const Goods& g2)
    35. 	{
    36. 		return g1._evaluate > g2._evaluate;
    37. 	}
    38. };
    39.  
    40. int main()
    41. {
    42. 	vector v = { { "苹果", 2.1, 4.9 }, { "香蕉", 3.3, 5.5 }, { "橙子", 2.2, 6.0 }, { "菠萝", 1.5, 3.6 } };
    43. 	sort(v.begin(), v.end(), ComparePriceLess());         //按价格升序排序
    44. 	sort(v.begin(), v.end(), ComparePriceGreater());      //按价格降序排序
    45. 	sort(v.begin(), v.end(), CompareEvaluateLess());      //按评价升序排序
    46. 	sort(v.begin(), v.end(), CompareEvaluateGreater());   //按评价降序排序
    47. 	return 0;
    48. }

                             

     ③仿函数能够解决这里的问题，但可能仿函数的定义位置可能和使用仿函数的地方隔得比较远，这就要求仿函数的命名必须要通俗易懂，否则会降低代码的可读性

    • 这种场景就比较适合使用lambda表达式
    • 每次调用sort函数时只需要传入一个lambda表达式指明比较方式即可，阅读代码的人一看到lambda表达式就知道本次排序的比较方式是怎样的，提高了代码的可读性。
    • lambda表达式是一个匿名函数，恰当使用lambda表达式可以让代码变得简洁，并且可以提高代码的可读性。 
    1. int main()
    2. {
    3. 	vector v = { { "苹果", 2.1, 4.9 }, { "香蕉", 3.3, 5.5 }, { "橙子", 2.2, 6.0 }, { "菠萝", 1.5, 3.6} };
    4.  
    5. 	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) { return g1._price < g2._price; }); //按价格升序排序
    6.  
    7. 	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) { return g1._price > g2._price; }); //按价格降序排序
    8.  
    9. 	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) { return g1._evaluate < g2._evaluate; }); //按评价升序排序
    10.  
    11. 	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) { return g1._evaluate < g2._evaluate; }); //按评价降序排序
    12. 	
    13. 	return 0;
    14. }

                     

                            

                    

    2.lambda表达式语法

    • lambda表达式完整的书写格式:  [ capture - list ] ( parameters ) mutable -> return-type { statement }

                     

    (1)参数说明

    • [ capture-list ]：捕捉列表。该列表总是出现在lambda函数的开始位置，编译器根据[ ]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
    • ( parameters )：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略。
    • mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略（即使参数为空）。
    • ->return-type：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可以省略。返回值类型明确情况下,也可省略，由编译器对返回类型进行推导。
    • { statement }：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。

                                                     

    lambda函数的参数列表和返回值类型都是可选部分，但捕捉列表和函数体是不可省略的

    1. int main()
    2. {
    3. 	[]{}; //最简单的lambda表达式,该lambda函数不能做任何事情
    4. 	return 0;
    5. }

                             

     (2)捕获列表说明

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

    • [var]：表示值传递方式捕捉变量var。
    • [=]：表示值传递方式捕获所有父作用域中的变量（成员函数包括this指针）。
    • [&var]：表示引用传递捕捉变量var。
    • [&]：表示引用传递捕捉所有父作用域中的变量（成员函数包括this指针）。
    • [this]：表示值传递方式捕捉当前的this指针。

                     

    ②补充

    • 父作用域指的是包含lambda函数的语句块。
    • 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。比如[=, &a, &b]。
    • 捕捉列表不允许变量重复传递，否则会导致编译错误。比如[=, a]重复传递了变量a。
    • 在块作用域以外的lambda函数捕捉列表必须为空，即全局lambda函数的捕捉列表必须为空。
    • 在块作用域中的lambda函数仅能捕捉父作用域中的局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。
    • lambda表达式之间不能相互赋值，即使看起来类型相同。
    1. void (*PF)();
    2.  
    3. int main()
    4. {
    5.  auto f1 = []{cout << "hello world" << endl; };
    6.  auto f2 = []{cout << "hello world" << endl; };
    7.  
    8.  // 此处先不解释原因，等lambda表达式底层实现原理看完后，就清楚了
    9.  //f1 = f2;   // 编译失败--->提示找不到operator=()
    10.  
    11.  // 允许使用一个lambda表达式拷贝构造一个新的副本
    12.  auto f3(f2);
    13.  f3();
    14.  
    15.  // 可以将lambda表达式赋值给相同类型的函数指针
    16.  PF = f2;
    17.  PF();
    18.  
    19.  return 0; 
    20. }

                            

                            

    3.lambda表达式的使用及注意事项

    (1)参数列表引用传参 交换数据

    • lambda表达式是一个匿名函数，该函数无法直接调用，如果想要直接调用，可借助auto将其赋值给一个对象，此时这个对象就可以像普通函数一样使用。
    • lambda表达式的函数体在格式上并不是必须写成一行，如果函数体太长可以进行换行，但换行后不要忘了函数体最后还有一个分号。
    1. int main()
    2. {
    3. 	int a = 10, b = 20;
    4.     //auto Swap = [](int& x, int& y){}; 简便写法，不必要的可以不写
    5. 	auto Swap = [](int& x, int& y)->void{
    6. 		int tmp = x;
    7. 		x = y;
    8. 		y = tmp;
    9. 	};
    10.  
    11. 	Swap(a, b); //交换a和b
    12. 	return 0;
    13. }

                     

     (2)利用捕捉列表进行捕捉交换数据

    ①以引用的方式捕捉所有父作用域中的变量，省略参数列表和返回值类型

    1. int main()
    2. {
    3. 	int a = 10, b = 20;
    4. 	auto Swap = [&]{
    5. 		int tmp = a;
    6. 		a = b;
    7. 		b = tmp;
    8. 	};
    9.  
    10. 	Swap(); //交换a和b
    11. 	return 0;
    12. }

                     

     ②只对父作用域中的a、b变量进行捕捉

    1. int main()
    2. {
    3. 	int a = 10, b = 20;
    4. 	auto Swap = [&a, &b]{
    5. 		int tmp = a;
    6. 		a = b;
    7. 		b = tmp;
    8. 	};
    9.  
    10. 	Swap(); //交换a和b
    11. 	return 0;
    12. }

                                     

    ③实际当我们使用[ & ]或[ = ]的方式捕获变量时，编译器也不一定会把父作用域中所有的变量捕获进来，编译器可能只会对lambda表达式中用到的变量进行捕获，没有必要把用不到的变量也捕获进来，这个主要看编译器的具体实现。 

                            

    (3)传值方式捕捉(临时变量),达不到交换数据的目的 

    • 如果以传值方式进行捕捉，那么首先编译不会通过，因为传值捕获到的变量默认是不可修改的，如果要取消其常量性，就需要在lambda表达式中加上mutable，并且此时参数列表不可省略
    • 但由于这里是传值捕捉，lambda函数中对a和b的修改不会影响外面的a、b变量，与函数的传值传参是一个道理，因此这种方法无法完成两个数的交换。
    1. int main()
    2. {
    3. 	int a = 10, b = 20;
    4. 	auto Swap = [a, b]()mutable{
    5. 		int tmp = a;
    6. 		a = b;
    7. 		b = tmp;
    8. 	};
    9.  
    10. 	Swap(); //交换a和b？
    11. 	return 0;
    12. }

                            

                    

            

    4.lambda表达式底层原理 

     (1)函数对象和lambda表达式的比较

    • 实际编译器在底层对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的。函数对象就是我们平常所说的仿函数，就是在类中对()运算符进行了重载的类对象。
    • 测试代码有一个Rate类，该类对()运算符进行了重载，因此Rate类实例化出的 r1 对象就叫做函数对象，r1 可以像函数一样使用。然后我们编写了一个lambda表达式，并借助auto将其赋值给 r2 对象，这时 r1 , r2 都可以像普通函数一样使用。
    1. class Rate
    2. {
    3. public:
    4. 	Rate(double rate) : _rate(rate)
    5. 	{}
    6.  
    7. 	double operator()(double money, int year)
    8. 	{
    9. 		return money * _rate * year;
    10. 	}
    11.  
    12. private:
    13. 	double _rate;
    14. };
    15.  
    16. int main()
    17. {
    18. 	// 函数对象
    19. 	double rate = 0.49;
    20. 	Rate r1(rate);
    21. 	r1(10000, 2);
    22.  
    23. 	// lambda表达式  
    24. 	auto r2 = [=](double monty, int year)->double { return monty * rate * year; };
    25. 	r2(10000, 2);
    26.  
    27. 	return 0;
    28. }

                             

    (2)查看底层汇编

    ①观察函数对象

    • 在创建函数对象 r1 时，会调用 Rate类的构造函数。
    • 在使用函数对象 r1 时，会调用 Rate类的 () 运算符重载函数。

                    

    ②观察lambda表达式

    • 借助auto将lambda表达式赋值给 r2 对象时，会调用 类的构造函数。
    • 在使用 r2 对象时，会调用 类的 () 运算符重载函数。

                     

    (3)本质就是因为lambda表达式在底层被转换成了仿函数

    • 当我们定义一个lambda表达式后，编译器会自动生成一个类，在该类中对 () 运算符进行重载，实际lambda函数体的实现就是这个仿函数的 operator() 实现。
    • 在调用lambda表达式时，参数列表和捕获列表的参数，最终都传递给了仿函数的 operator ()
    • lambda表达式和范围for是类似的，它们在语法层面上看起来都很神奇，但实际范围for底层就是通过迭代器实现的，lambda表达式底层的处理方式和函数对象是一样的 

                     

    (4)lambda表达式之间不能相互赋值 

    ①lambda表达式之间不能相互赋值，即使是两个一模一样的lambda表达式

    • 因为lambda表达式底层的处理方式和仿函数是一样的，在VS下，lambda表达式在底层会被处理为函数对象，该函数对象对应的类名叫做。
    • 类名中的uuid叫做通用唯一识别码（Universally Unique Identifier），简单来说，uuid就是通过算法生成一串字符串，保证在当前程序当中每次生成的uuid都不会重复。
    • lambda表达式底层的类名包含uuid，这样就能保证每个lambda表达式底层类名都是唯一的。

                     

    ②所以每个lambda表达式的类型都是不同的，这也就是lambda表达式之间不能相互赋值的原因

                             

    ③编译器只需要保证每个lambda表达式底层对应类的类名不同即可，并不是每个编译器都会将lambda表达式底层对应类的类名处理成 ，vs是这样弄的。 

                    

                                    

    5.可调用对象

    • C           函数指针
    • C++98   仿函数
    • C++11   lambda 
    •               包装器

     

     

  • 相关阅读:
    HTML5七夕情人节表白网页制作【满天星空3D相册】HTML+CSS+JavaScript 3D动态相册网页代码
    基于区块链的隐私保护数据共享
    Centos配置samba文件共享服务器
    D. Number into Sequence【1300】
    【复盘】记录一次JVM 异常问题 java.lang.OutOfMemoryError: unable to create new native thread
    Mac 重新安装系统
    Python 中调用 Java 的 JAR 包
    从数学角度和编码角度解释 熵、交叉熵、KL散度
    TypeScript & React（上）
    轨迹纠偏解决方法
  • 原文地址：https://blog.csdn.net/m0_52169086/article/details/126918911