深入理解C++ Lambda表达式:语法、用法与原理及其包装器的使用

深入理解C++ Lambda表达式:语法、用法与原理及其包装器的使用

  • lambda表达式
    • C++98中的一个例子
    • lambda表达式语法
      • lambda表达式各部分说明
      • 捕获列表说明
    • 函数对象与lambda表达式
  • 包装器
    • function包装器
  • bind

🌏个人博客主页: 个人主页

在这里插入图片描述

本文深入介绍了C++中的Lambda表达式的语法、用法、捕获列表以及其底层原理,强调了其作为函数对象的功能。还探讨了标准库中std::function包装器和std::bind函数的应用,通过它们可以灵活地封装、绑定和简化可调用对象的处理,提升代码的简洁性和可读性。

lambda表达式

C++98中的一个例子

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

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

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

struct Goods
{string _name; //名字double _price;//价格int _ecaluate;//评价//...Goods(const char* str,double price,int evaulate):_name(str),_price(price),_ecaluate(evaulate){}
};	

如果我们用运算符重载的方法控制比较逻辑,只能控制一种比较方法,但是如果我们希望希望按照价格,或者评价,名字来排序就没办法实现,所以我们可以通过仿函数来完成。

例如我们如果希望按照价格比较,就提供对应的仿函数:

struct ComparePriceLess
{bool operator()(const Goods& gl, const Goods& gr){return gl._price > gr._price;}
};struct ComparePriceGreater
{bool operator()(const Goods& gl, const Goods& gr){return gl._price < gr._price;}
};
int main()
{vector<Goods> v = { {"苹果",2.1,5},{"香蕉",3,4},{"橙子",2.2,3},{"菠萝",1.5,4} };sort(v.begin(), v.end(), ComparePriceGreater());sort(v.begin(), v.end(), ComparePriceLess());return 0;
}

但是这里还是有的不方便,每次为了实现一个algorithm算法,都要重新去写一个类,如果每次比较的逻辑不一样,还要去实现多个类,特别是相同类的命名,这些都给编程者带来了极大的不便。因此,在C++11语法中出现了Lambda表达式。

lambda表达式语法

lambda表达式书写格式:

[capture-list] (parameters) mutable -> return-type { statement }

lambda表达式各部分说明

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

注意:

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

如果我们要用lamba表达式写一个两个变量相加的函数,可以这么写。

[](int x, int y)->int {return x + y; };

这个表达式就是一个lamba对象,可以像函数一样直接调用,但是对这个lamba表达式直接调用不太方便,我们通常都是赋值给一个lamba对象,这个对象的类型可以使用auto进行推导。

int main()
{auto add1 = [](int x, int y)->int {return x + y; };cout << add1(1, 2) << endl;
}

auto add1 = [ ](int x, int y) -> int { return x + y; }; 这行代码会先生成一个 lambda 对象,并将其赋值给 add1

int main()
{auto add1 = [](int x, int y)->int {return x + y; };cout << add1(1, 2) << endl;auto func1 = []{//返回值可自动推导类型,所以可以省略//无参数可以省略cout << "hello world" << endl;return 0;};func1();return 0;
}

如果我们不想用仿函数,来完成比较逻辑,就可以这样写:

int main()
{vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
3 }, { "菠萝", 1.5, 4 } };// 价格升序sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool{return g1._price < g2._price;});sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool{return g1._price > g2._price;});sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool{return g1._evaluate < g2._evaluate;});sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool{return g1._evaluate > g2._evaluate;});return 0;
}

捕获列表说明

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

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

注意:

  1. 父作用域指包含lambda函数的语句块
  2. 语法上捕捉列表可由多个捕捉项组成,并以逗号分割。
    • [=, &a, &b]:以引用传递的方式捕捉变量a和b,值传递方式捕捉其他所有变量。
    • [&,a, this]:值传递方式捕捉变量a和this,引用方式捕捉其他变量。
  3. 捕捉列表不允许变量重复传递,否则就会导致编译错误。
    • [=, a]:=已经以值传递方式捕捉了所有变量,捕捉a重复。
  4. 在块作用域以外的lambda函数捕捉列表必须为空。
  5. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量,捕捉任何非此作用域或者非局部变量都会导致编译报错,但是可以使用全局域的。
  6. lambda表达式之间不能相互赋值,即使看起来类型相同,因为编译器生成的类名不同。
int x = 0;int main()
{// 只能用当前lambda局部域和捕捉的对象和全局对象int a = 0, b = 1, c = 2, d = 3;// 所有值传值捕捉auto func1 = [=]{int ret = a + b + c + d + x;return ret;};// 所有值传引用捕捉auto func2 = [&]{a++;b++;c++;d++;int ret = a + b + c + d;return ret;};// 混合捕捉auto func3 = [&a, b]{a++;// b++;int ret = a + b;return ret;};// 混合捕捉// 所有值以引用方式捕捉,d用传值捕捉auto func4 = [&, d]{a++;b++;c++;//d++;int ret = a + b + c + d;};// 混合捕捉// 所有值以传值方式捕捉,d用传引用捕捉auto func5 = [=, &d](){//a++;//b++;//c++;d++;int ret = a + b + c + d;};return 0;
}

因为捕获列表只能捕捉父作用域的对象,因为,成员函数默认传的是this指针,所在,这里应该捕捉的应该this指针。

class AA
{
public:void func(){//auto f1 = [this]auto f1 = [=]{cout << _a1 << endl;cout << _a2 << endl;};}
private:int _a1 = 1;int _a2 = 2;
};

函数对象与lambda表达式

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

int main()
{double rate = 0.03;Rate r1(rate);cout << r1(10000, 2) << endl;//600auto r2 = [rate](double money, int year)->double{return rate * money * year;};cout << r2(10000, 2) << endl;//600
}

从使用方式上来看,函数对象与lambda表达式完全一样。

函数对象将rate作为其成员变量,在定义对象时给出初始值即可,然后再调用重载的operator()。

在C++中,lambda表达式通过捕获列表捕获外部变量,并将这些变量作为成员变量存储在lambda对象中。lambda对象的调用本质上是调用其 operator() 成员函数。

捕获列表和成员变量

  1. 捕获列表:
    • 捕获列表用于指定 lambda 表达式可以访问哪些外部变量。
    • 捕获列表中的变量会被存储为 lambda 对象的成员变量。
  2. 成员变量:
    • 捕获的变量在 lambda 对象内部被存储为成员变量。
    • 捕获列表中的变量可以通过值捕获(=)或引用捕获(&)。

构造函数的初始化参数

  • 构造函数:
    • lambda 对象的构造函数会使用捕获列表中的变量来初始化成员变量。

调用 operator() 成员函数

  • 调用:
    • 当你调用 lambda 对象时,实际上是调用了其 operator() 成员函数。
    • operator() 成员函数包含了 lambda 表达式的主体代码。

在这里插入图片描述

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

包装器

function包装器

template <class T> function;     // undefined
template <class Ret, class... Args> class function<Ret(Args...)>;
//模板参数说明:
//Ret: 被调用函数的返回类型
//Args…:被调用函数的形参

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

包装器包装的是可调用对象,可调用对象一般有三类:函数指针(类型不好写),仿函数(需要单独写一个类),lamba(没办法写类型)。

//普通函数
int f(int a, int b)
{return a + b;
}
//仿函数
struct Functor
{
public:int operator()(int a, int b){return a + b;}
};
int main()
{//function包装可调用对象,可以统一类型function<int(int, int)> f1 = f;function<int(int, int)> f2 = Functor();function<int(int, int)> f3 = [](int a, int b)->int {return a + b; };return 0;
}

通过一个命令就对应一个动作,也就是说一个字符串对应一个函数(可调用对象),这里我们会通常使用map实现,但是map的第二个参数可能是函数指针,仿函数对象,lamba对象。

如果第二个参数个函数指针的话虽然可以实现但是函数指针类型写起来太麻烦,如果用仿函数的类型实现的话就只能固定死一种类型,lamba表达式没有类型,所以这里就可以使用function来实现,可接受各种类型。

int main()
{function<int(int, int)> f1 = f;function<int(int, int)> f2 = Functor();function<int(int, int)> f3 = [](int a, int b)->int {return a + b; };map < string, function<int(int, int)>> opFuncMap;opFuncMap["函数指针"] = f1;opFuncMap["仿函数"] = f2;opFuncMap["lamba"] = f3;cout << opFuncMap["函数指针"](2, 3) << endl; //5cout << opFuncMap["仿函数"](2, 3) << endl;	// 5cout << opFuncMap["lamba"](2, 3) << endl;  //5return 0;
}

function包装器简化代码,求解逆波兰表达式的步骤如下:

class Solution {
public:int evalRPN(vector<string>& tokens) {stack<int> st;  // 创建一个栈用于存储中间结果// 定义一个映射,将字符串操作符映射到对应的 lambda 表达式map<string, function<int(int, int)>> op = {{"+", [](int a, int b) { return a + b; }},{"-", [](int a, int b) { return a - b; }},{"*", [](int a, int b) { return a * b; }},{"/", [](int a, int b) { return a / b; }}};// 遍历输入的逆波兰表达式for (const auto& str : tokens) {// 如果当前字符串是操作符if (op.count(str)) {// 从栈中弹出两个操作数int right = st.top();st.pop();int left = st.top();st.pop();// 应用对应的操作符,并将结果压入栈中st.push(op[str](left, right));} else {// 如果当前字符串是数字,将其转换为整数并压入栈中st.push(stoi(str));}}// 栈顶元素即为最终结果return st.top();}
};

function还可以包装成员函数。

class Plus
{
public://静态成员函数static int plusi(int a, int b){return a + b;}//普通成员函数double plusd(double a, double b){return a + b;}
};int main()
{//包装静态成员函数function<int(int, int)> f1 = Plus::plusi;//包装普通成员函数Plus p;function<double(Plus* ,double, double)> f2 = &Plus::plusd;cout << f2(&p, 1.1, 2.0) << endl;function<double(Plus, double, double)> f3 = &Plus::plusd;cout << f3(p, 1.1, 2.0) << endl;return 0;
}

注意:

  1. 规定类的成员函数名取地址才是成员函数的地址。
  2. 成员函数的第一个默认的参数是this指针,这里为什么这里的第一个参数用对象也可以呢?

其实包装器包装对象的本质也是一个仿函数,实际要包装的对象作为自己的成员变量这样的方式存起来,然后调用operator(),operator()函数里面再去要包装的可调用对象,所以,这里的第一个参数只是为了调用operator(),所以这里使用指针,对象都可以调用成员函数。

bind

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

// 原型如下:
template <class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
// with return type (2) 
template <class Ret, class Fn, class... Args>
/* 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为第二个参数,以此类推。

int Sub(int a ,int b)
{return a - b;
}int SubX(int a, int b,int c)
{return a - b - c;
}using placeholders::_1;
using placeholders::_2;
using placeholders::_3;int main()
{//调整参数顺序auto sub1 = bind(Sub, _1, _2);cout << sub1(10, 5) << endl;//绑定本质返回是防函数//调整参数顺序//_1代表第一个实参//_2代表第二个实参auto sub2 = bind(Sub, _2, _1);cout << sub2(10, 5) << endl;//调整参数个数auto sub3 = bind(Sub, 100, _1);cout << sub3(5) << endl;auto sub4 = bind(Sub, _1, 100);cout << sub3(5) << endl;auto sub5 = bind(SubX, 100, _1, _2);cout << sub5(5, 10);auto sub6 = bind(SubX, _1,100, _2);cout << sub6(5, 10);auto sub7 = bind(SubX, _1, _2, 100);cout << sub7(5, 10);}

function在包装成员函数的时候第一个参数显示传比较麻烦这里就可以使用bind进行绑定。

//bind一般用于绑定一些固定参数
function<double(double, double)> f3 = bind(&Plus::plusd, Plus(), _1, _2);
int main()
{auto func = [](double rate, double money, int year)->double{int ref = 0;for (size_t i = 0; i < year; i++){ref += money * rate;money += money * rate;}return ref;};function<double(double)> func_3_1_5 = bind(func, 0.015, _1, 3);function<double(double)> func_5_1_5 = bind(func, 0.015, _1, 5);function<double(double)> func_30_1_5 = bind(func, 0.015, _1, 30);cout << func_3_1_5(100000) << endl;cout << func_3_1_5(100000) << endl;cout << func_3_1_5(100000) << endl;return 0;
}

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/web/57353.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

2024最新Instagram养号攻略!海外社媒起号码住了

Instagram至今仍然是全球顶级的流量平合&#xff0c;不仅在国外是各大网红明星必备app&#xff0c;国内下载量也居高不下&#xff0c;但从2018年下半年开始加大了对新账号的监控和权限限制。新注册的账号会受到诸多限制&#xff0c;稍不慎就会进入安全模式或者被封&#xff0c;…

【vue】10.组件的生命周期-从Vue 2到Vue 3的演变

自Vue 2发布以来&#xff0c;它以其简单易用、灵活高效的特点赢得了众多开发者的喜爱。随着时间的推移&#xff0c;Vue 3在Vue 2的基础上进行了全面升级&#xff0c;其中包括对组件生命周期的调整。本文将首先回顾Vue 2的组件生命周期&#xff0c;然后重点介绍Vue 3组件生命周期…

STM32 HAL 点灯

首先从点灯开始 完整函数如下&#xff1a; #include "led.h" #include "sys.h"//包含了stm32f1xx.h&#xff08;包含各种寄存器定义、中断向量定义、常量定义等&#xff09;//初始化GPIO口 void led_init(void) {GPIO_InitTypeDef gpio_initstruct;//打开…

计算合约方法的签名

计算合约方法的签名 通过智能合约实现 // SPDX-License-Identifier: MIT pragma solidity ^0.8.26;contract FunctionSelector {/*"transfer(address,uint256)"0xa9059cbb"transferFrom(address,address,uint256)"0x23b872dd*/function getSelector(stri…

【Java】方法的使用 —— 语法要求、方法的重载和签名、方法递归

目录 1. 方法基础知识 1.1 方法的概念 1.2 语法格式 * 注意事项【与C不同】 1.3 return —— 返回值的严格检查【比C语言严格】 2. 形参与实参的关系 3. 方法重载 3.1 什么是方法重载&#xff1f;为什么要方法重载&#xff1f; 3.2 方法重载的规则 4. 方法签名 5. 递…

鸿蒙开发:arkts Refresh 组件

基本概念 在 ArkTS 5.0 中&#xff0c;Refresh组件是用于实现下拉刷新功能的重要元素。它为用户提供了一种直观的方式来获取最新的数据。当用户在界面上对Refresh组件所在的区域进行下拉操作时&#xff0c;如果满足一定的触发条件&#xff0c;就会触发刷新事件&#xff0c;从而…

ClickHouse 神助攻:纽约城市公共交通管理(MTA)数据应用挑战赛

本文字数&#xff1a;13198&#xff1b;估计阅读时间&#xff1a;33 分钟 作者&#xff1a;The PME Team 本文在公众号【ClickHouseInc】首发 我们一向对开放数据挑战充满热情&#xff0c;所以当发现 MTA&#xff08;城市交通管理局&#xff09;在其官网发起了这样的挑战时&…

HarmonyOS开发5.0 net 启动界面设置

第一步、创建我们界面 第二步&#xff0c; 在EntryAbility中配置启动页面&#xff0c;在entry/src/main/ets/entryability/EntryAbility.ets中配置启动页面 配置如下 至此大功告成

算法笔记day10

目录 1.牛牛冲钻五 2.最长无重复子数组_牛客题霸_牛客网 3.重排字符串 1.牛牛冲钻五 算法思路&#xff1a; 特别简单的模拟题&#xff0c;没什么说的。 #include <iostream> #include <vector> #include <string> using namespace std; int main() { …

ETF申购赎回指南:详解注意事项与低费率券商推荐!

​ETF 申购&赎回 ETF申购赎回是个啥业务&#xff1f; 01 ETF申购、赎回是一种交易委托方式&#xff0c;指投资者通过申购方式(买入方向)获得ETF份额&#xff0c;通过赎回的方式&#xff08;卖出方向&#xff09;换掉/卖出ETF份额。ETF申购&#xff0c;通常是通过一篮子成…

LinkedList和链表之刷题课(下)

1. 给定x根据x把链表分割,大的结点放在x后面,小的结点放在x前面 题目解析: 注意此时的pHead就是head(头节点的意思) 基本上就是给定一个链表,我们根据x的值来把这个链表分成俩部分,大的那部分放在x后面,小的那部分放在x前面,并且我们不能改变链表本来的顺序,比如下面的链表,我…

UI 组件的二次封装

UI 组件的二次封装是指&#xff0c;在基础 UI 库的组件上进行自定义封装&#xff0c;以实现更贴合业务需求的功能和样式。通过二次封装&#xff0c;可以增强组件的复用性、便捷性和一致性&#xff0c;简化业务代码&#xff0c;同时降低后续维护成本。 1. 二次封装的原理 二次…

ELK + Filebeat + Spring Boot:日志分析入门与实践(二)

目录 一、环境 1.1 ELKF环境 1.2 版本 1.3 流程 二、Filebeat安装 2.1 安装 2.2 新增配置采集日志 三、logstash 配置 3.1 配置输出日志到es 3.2 Grok 日志格式解析 3.2 启动 logstash ​3.3 启动项目查看索引 一、环境 1.1 ELKF环境 springboot项目&#xff1a;w…

二百七十、Kettle——ClickHouse中增量导入清洗数据错误表

一、目的 比如原始数据100条&#xff0c;清洗后&#xff0c;90条正确数据在DWD层清洗表&#xff0c;10条错误数据在DWD层清洗数据错误表&#xff0c;所以清洗数据错误表任务一定要放在清洗表任务之后。 更关键的是&#xff0c;Hive中原本的SQL语句&#xff0c;放在ClickHouse…

一篇文章入门梅尔频率倒谱系数

文章目录 梅尔频率倒谱系数MFCC预处理预加重分帧加窗 FFT&#xff08;Fourier-Transform&#xff09;功率谱滤波器组梅尔频率倒谱系数&#xff08;MFCC&#xff09;均值归一化总结 参考文献 梅尔频率倒谱系数MFCC 梅尔倒谱系数&#xff08;Mel-scale FrequencyCepstral Coeffi…

Qt的信号槽机制学习一

一、Qt理论知识简记 &#xff08;一&#xff09;信号与槽[1] 信号与槽是Qt编程的基础&#xff0c;其使得处理界面上各个组件的交互操作变得比较直观和简单&#xff0c;GUI&#xff08;Graphical User Interface&#xff09;程序设计的主要工作就是对界面上各组件的信号进行相应…

程序员的相亲囧途:三万相亲费,能否换回真爱?

在快节奏的都市生活中&#xff0c;相亲已成为不少单身男女寻找另一半的重要途径。然而&#xff0c;宁波的唐先生却在这条路上遭遇了不小的挫折。28岁的他&#xff0c;身高1米78&#xff0c;本应是相亲市场上的“香饽饽”&#xff0c;却在“我主良缘”交了三万块钱相亲费后&…

【Android】使用TextView实现按钮开关代替Switch开关

介绍 Android 本身自己带的有开关控件&#xff0c;但是很多时候我们是不愿意使用这种开关的&#xff0c;感觉使用起来比较麻烦&#xff0c;特别是遇到需要延迟操作的情况。 比如有一个需求是这样的&#xff1a;我们需要打开一个设置&#xff0c;但是这个设置是否打开需要经过…

AI自媒体变现路径大盘点!建议收藏!

当下的我做为一人公司或者超级个体为目标的创业模式&#xff0c;无论是在写作、图文和短视频输出方面&#xff0c;我都是运用了N个AI工具来提升我的生产力。 这种创业模式就是一个人N个AI的模式&#xff0c;我们可以通过AI工具做提效来赚取差价&#xff0c;以时间复利来累计财…

Python的协程与传统的线程相比,是否能更有效地利用计算资源?在多大程度上,这种效率是可测量的?如何量化Python协程的优势|协程|线程|性能优化

目录 1. 协程与线程的基本概念 1.1 线程 1.2 协程 2. 协程的实现原理 2.1 基本示例 3. 协程与线程的效率对比 3.1 资源利用率 3.2 性能测试 4. 使用场景分析 4.1 适用场景 4.2 不适用场景 5. 性能监测与测量 5.1 使用时间记录 5.2 使用第三方库 6. 总结与展望 P…