当前位置： 首页 > news >正文

C++11：lambda表达式

news 来源：原创 2024/5/18 12:39:34

目录

一.lambda表达式

1.格式

2. lambda表达式各部分说明

3.举例

（1）例子1：相加函数

 （2）[ ]捕捉列表 例子2：交换函数

        仿函数比较，lambda更易懂

 4.lambda注意点

5.底层原理

二.包装器

1.可调用类型对象

2.function包装器

3.bind

一.lambda表达式

lambda表达式就是定义了一个可调用的匿名函数，一般在局部。

1.格式

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

     [capture-list] (parameters) mutable -> return-type { statement }
     捕捉列表          参数  去const（单词意思易变的）   返回值       函数体

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

2. lambda表达式各部分说明

（1）[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来
判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda 函数使用。
捕捉的参数都是自带const的，想要去掉const属性可以用 mutable，但是捕捉的对象(变量)仍是一份拷贝，外部的a，b无法被修改，所以mutable 很少用，意义不大，不如用 [&]引用捕捉 ( )引用传参
（2）(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以
连同()一起省略。所传参数都是
（3）mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量
性。使用该修饰符时，参数列表不可省略(即使参数为空时，也要带上小括号)。mutable 只是让传值捕捉变量const属性去掉了，但是捕捉的a，b仍是拷贝，外部的a，b无法被修改，所以mutable 很少用，意义不大
（4）->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回
值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推 导。
（5）{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获
到的变量。
注意：
在lambda函数定义中，参数列表和返回值类型都是可省略部分，而捕捉列表和函数体可以为
空，但不可省略，因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。

3.举例

（1）例子1：相加函数

    int a = 0, b = 200;
	// [capture-list] (parameters) mutable -> return-type { statement }
	// 捕捉列表  参数  返回值  函数体

	// 一般是局部匿名函数  也可以写到全局
	auto Add1 = [](int x, int y)->double {return (x + y) / 3.0; };
	auto Add2 = [](int x, int y)->int {return (x + y) / 3.0; };//传参写法
	auto Add3 = [a, b] {return (a + b) / 3.0; };//捕捉变量写法

	cout << Add1(a, b) << endl;
	cout << Add2(a, b) << endl;
	cout << Add3() << endl;

 （2）[ ]捕捉列表 例子2：交换函数

3,4,5,6是几种捕捉方式

1.	auto Swap1 = [](int& x, int& y){
		int tmp = x;
		x = y;
		y = tmp;
	};

	Swap1(a, b);
	cout << a << " " << b << endl;

2.	mutable 只是让传值捕捉变量const属性去掉了，但是捕捉的a，b仍是拷贝，外部的a，b无法被修改
	/*auto Swap2 = [a, b]()mutable{
		int tmp = a;
		a = b;
		b = tmp;
	};*/

	用引用的方式捕捉:
	auto Swap2 = [&a, &b]{
		int tmp = a;
		a = b;
		b = tmp;
	};

	Swap2();
	cout << a << " " << b << endl;

3.	int c =2, d=3, e=4, f=5, g=6, ret;
	传值捕捉全部对象
	auto Func1 = [=]{
		return c + d*e / f + g;
	};

	cout << Func1() << endl;

4.	传引用捕捉全部对象
	auto Func2 = [&]{
		ret = c + d*e / f + g;
	};

	Func2();
	cout << ret << endl;

5.	混着捕捉
	auto Func3 = [c, d, &ret]{
		ret = c + d;
	};

	Func3();
	cout << ret << endl;

6.	ret传引用捕捉 其他全部传值捕捉
	auto Func4 = [=, &ret]{
		ret = c + d*e / f + g;
		//c = 1;
	};

	Func4();
	cout << ret << endl;

        仿函数比较，lambda更易懂

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

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

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

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()
{
	// C/C++98
	int i = 0;
	double d1 = i;
	const double& d2 = i;

	// C++98
	string str1 = "11111";
	const string& str2 = "11111";

	// C++11
	Goods g1 = { "苹果", 2.1, 5 };
	const Goods& g2 = { "苹果", 2.1, 5 };


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

	//sort(v.begin(), v.end()); 自定义类型没重载<不能用less或者greater
	sort(v.begin(), v.end(), Compare1());
	sort(v.begin(), v.end(), ComparePriceLess());
	sort(v.begin(), v.end(), ComparePriceGreater());

1.	auto com1 = [](const Goods& g1, const Goods& g2){return g1._price < g2._price; };
	sort(v.begin(), v.end(), com1);

2.	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
		return g1._price < g2._price; });
	
	cout << endl;

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

	cout << endl;

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

	cout << endl;

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

	cout << endl;

	return 0;
}

 4.lambda注意点

（1）父作用域指包含lambda函数的语句块
（2） 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量
[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量
（3）捕捉列表不允许变量重复传递，否则就会导致编译错误。
比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复
（4） 在块作用域以外的lambda函数捕捉列表必须为空。
（5）在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者
非局部变量（捕捉        全局变量会报错）都会导致编译报错。
（6）lambda对象之间不能相互赋值，即使看起来类型相同 ，因为每个lambda都会被转换成一个仿函数类型，仿函数类名称lambda+ uuid。（ lambda表达式底层被转换成仿函数）

但是允许使用lambda表达式拷贝构造

也可以将lambda表达式赋值给相同类型的函数指针，了解一下，一般不建议这么用，意义不大

void (*PF)();
int main()
{
	auto f1 = [] {cout << "hello world" << endl; };
	auto f2 = [] {cout << "hello world" << endl; };
	
 //f1 = f2;   // 编译失败--->提示找不到operator=()
	// 允许使用一个lambda表达式拷贝构造一个新的副本
	auto f3(f2);
	f3();
	// 可以将lambda表达式赋值给相同类型的函数指针，了解一下，一般不建议这么用
	PF = f2;
	PF();
	return 0;
}

5.底层原理

lambda表达式底层是一个仿函数。每个lambda都会被转换成一个仿函数类型，仿函数类名称lambda+ uuid。

二.包装器

1.可调用类型对象

1、函数指针
2、仿函数对象
3、lambda

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

	// lamber表达式
	cout << useF([](double d)->double{ return d / 4; }, 11.11) << endl;

	return 0;
}

 

通过上面的程序验证，我们会发现useF函数模板实例化了三份。

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

2.function包装器

template <class Ret, class... Args>

class function < Ret ( Args ...) > ;
模板参数说明：
Ret : 被调用函数的返回类型
Args… ：被调用函数的形参 
int f(int a, int b)
{
	return a + b;
}

struct Functor
{
public:
	int operator() (int a, int b)
	{
		return a + b;
	}
};

class Plus
{
public:
	static int plusi(int a, int b)
	{
		return a + b;
	}

	double plusd(double a, double b)
	{
		return a + b;
	}
};

int main()
{
	std::function<int(int, int)> func1 = f;
	cout << func1(1, 2) << endl;

	std::function<int(int, int)> func2 = Functor();
	cout << func2(10, 20) << endl;
	
     静态成员函数包装可以加&也可以不加
	std::function<int(int, int)> func3 = &Plus::plusi;
	cout << func3(100, 200) << endl;

	 规定：非静态成员函数包装必须加&，和域名，参数多一个域
	std::function<double(Plus, double, double)> func4 = &Plus::plusd;
	cout << func4(Plus(), 100.11, 200.11) << endl;

	std::function<int(int, int)> func5 = [](int a, int b) {return a + b; };
	cout << func5(100, 200) << endl;

	return 0;
}

 


#include <functional>

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()
{
	// 函数名
	std::function<double(double)> func1 = f;
	cout << useF(func1, 11.11) << endl;

	// 函数对象
	std::function<double(double)> func2 = Functor();
	cout << useF(func2, 11.11) << endl;

	// lamber表达式
	std::function<double(double)> func3 = [](double d)->double{ return d / 4; };
	cout << useF(func3, 11.11) << endl;

	return 0;
}

3.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 f(int a, int b)
{
	return a - b;
}

struct Functor
{
public:
	int operator() (int a, int b)
	{
		return a + b;
	}
};


class Plus
{
public:
	Plus(int x = 2)
		:_x(x)
	{}

	int plusi(int a, int b)
	{
		return (a + b)*_x;
	}
private:
	int _x;
};

int main()
{
	std::function<int(int, int)> func1 = f;
	cout << func1(1, 2) << endl;

	std::function<int(int, int)> func2 = Functor();
	cout << func2(10, 20) << endl;

	// 3个参数
	std::function<int(Plus, int, int)> func3 = &Plus::plusi;
	cout << func3(Plus(), 100, 200) << endl;

	// 调整可调用对象的参数个数和顺序
	// _1 _2 _3... 表示你要自己传的那些参数，_1表示第一个参数传给_1
	// 调整个数
	// 2个参数
	std::function<int(int, int)> func4 = std::bind(&Plus::plusi, Plus(10), placeholders::_1, placeholders::_2);

	// 1个参数
	std::function<int(int)> func5 = std::bind(&Plus::plusi, Plus(10),
		10, placeholders::_1);

	cout << func5(200) << endl;

	// 调整顺序 -- 用处不大
	std::function<int(int, int)> func6 = std::bind(f, placeholders::_2, placeholders::_1);
	cout << func1(66, 77) << endl;
	cout << func6(66, 77) << endl;

	map<string, std::function<int(int, int)>> opFuncMap =
	{
		{ "普通函数指针", f },
		{ "函数对象", Functor() },
		{ "成员函数指针", std::bind(&Plus::plusi, Plus(10), placeholders::_1, placeholders::_2) }
	};

	cout << opFuncMap["普通函数指针"](1, 2) << endl;
	cout << opFuncMap["函数对象"](1, 2) << endl;
	cout << opFuncMap["成员函数指针"](1, 2) << endl;


	return 0;
}

相关文章：

  • [实践篇]13.6 QNX侧如何抓取日志？
  • Java中如何检测一个元素是否存在于HashSet对象中呢？
  • Cesium：OSGB倾斜摄影模型加载卡顿优化
  • (附源码)计算机毕业设计ssm-Java网名推荐系统
  • 图解LeetCode——1694. 重新格式化电话号码（难度：简单）
  • 如何测试 Redis 缓存？
  • 二叉树的一些基本操作
  • 湖仓一体电商项目（二十四）：合并Iceberg小文件
  • Java中如何向一个HashSet对象中添加元素呢？
  • 静态HTML CSS网站制作成品 简单的学生网页作业代码【带视频演示】
  • 达梦数据库整合在springboot的使用教程
  • 【Linux】Linux的基本指令（Linux入门、用户的创建和切换）
  • C语言进阶——动态内存管理
  • C#面向对象程序设计课程实验一：实验名称：C#语言基础、程序流程控制
  • 公司级攻防比赛常用的突破方法
  • 【JavaScript】通过闭包创建具有私有属性的实例对象
  • 【跃迁之路】【585天】程序员高效学习方法论探索系列（实验阶段342-2018.09.13）...
  • JSONP原理
  • js中forEach回调同异步问题
  • Lsb图片隐写
  • Rancher如何对接Ceph-RBD块存储
  • uva 10370 Above Average
  • Zepto.js源码学习之二
  • 阿里云前端周刊 - 第 26 期
  • 闭包,sync使用细节
  • 基于Vue2全家桶的移动端AppDEMO实现
  • 如何邀请好友注册您的网站(模拟百度网盘)
  • 入口文件开始，分析Vue源码实现
  • 它承受着该等级不该有的简单， leetcode 564 寻找最近的回文数
  • 延迟脚本的方式
  • 在GitHub多个账号上使用不同的SSH的配置方法
  • 在weex里面使用chart图表
  • 京东物流联手山西图灵打造智能供应链，让阅读更有趣 ...
  • 正则表达式-基础知识Review
  • ​ssh免密码登录设置及问题总结
  • !! 2.对十份论文和报告中的关于OpenCV和Android NDK开发的总结
  • # include “ “ 和 # include ＜ ＞两者的区别
  • #常见电池型号介绍 常见电池尺寸是多少【详解】
  • $.ajax()
  • (delphi11最新学习资料) Object Pascal 学习笔记---第7章第3节（封装和窗体）
  • （八）Flask之app.route装饰器函数的参数
  • （第27天）Oracle 数据泵转换分区表
  • （推荐）叮当——中文语音对话机器人
  • （一）SpringBoot3---尚硅谷总结
  • （原创）Stanford Machine Learning (by Andrew NG) --- (week 9) Anomaly DetectionRecommender Systems...
  • (转)chrome浏览器收藏夹（书签）的导出与导入
  • (自适应手机端)响应式新闻博客知识类pbootcms网站模板 自媒体运营博客网站源码下载
  • .h头文件 .lib动态链接库文件 .dll 动态链接库
  • .Net mvc总结
  • .net wcf memory gates checking failed
  • .net 调用php,php 调用.net com组件 --
  • .NET（C#、VB）APP开发——Smobiler平台控件介绍：Bluetooth组件
  • .Net的DataSet直接与SQL2005交互
  • .net反编译的九款神器
  • .NET开发人员必知的八个网站