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

news2025/10/31 17:35:22

目录

一.背景

二.lambda

1.见一见lambda

2.lambda表达式语法

3.lambda捕捉列表说明

三.函数对象与lambda表达式

四.包装器

1.function包装器

2.包装类的成员函数

 五.bind

1.调整参数位置

2.减少函数参数

一.背景

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

#include<algorithm>
#include<vector>
using namespace std;

void Print(vector<int>& arr)
{
	for (auto e : arr)
	{
		cout << e << " ";
	}
	cout << endl;
}

int main()
{
	vector<int> arr = { 4,1,8,5,3,7,0,9,2,6 };

	//降序
	sort(arr.begin(), arr.end(),greater<int>());
	Print(arr);
	//升序
	sort(arr.begin(), arr.end());
	Print(arr);

	return 0;
}

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

struct Goods
{
	string _name;  //名字
	double _price; //价格
	int _evaluate; //评价
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(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;
	}
};

void Print(vector<Goods>& v)
{
	for (auto e : v)
	{
		cout << e._name << ":" << e._price << ":" << e._evaluate << endl;
	}
	cout << endl;
}
int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,3 }, { "菠萝", 1.5, 4 } };
	sort(v.begin(), v.end(), ComparePriceLess());
	Print(v);
	sort(v.begin(), v.end(), ComparePriceGreater());
	Print(v);
	return 0;
}

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

二.lambda

1.见一见lambda

改装上面的代码：

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

void Print(vector<Goods>& v)
{
	for (auto e : v)
	{
		cout << e._name << ":" << e._price << ":" << e._evaluate << endl;
	}
	cout << endl;
}
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; });
	Print(v);
	sort(v.begin(), v.end(), [](const Goods g1, const Goods g2)->bool {return g1._price > g2._price; });
	Print(v);
	return 0;
}

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

2.lambda表达式语法

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

[capture-list] :

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

int main()
{
	int a = 100;
	int b = 200;
	int sum = 0;
	auto lam = [a, b]()->int {return a + b; };
	sum = lam();
	cout << "a + b = "<<sum << endl;
	return 0;
}

(parameters)：

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

int main()
{
	int a = 100;
	int b = 200;
	int sum = 0;
	auto lam = [](int a,int b)->int {return a + b; };
	sum = lam(a,b);
	cout << "a + b = "<<sum << endl;
	return 0;
}

mutable：

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

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

int main()
{
	int a = 100;
	int b = 200;
	int sum = 0;
	auto lam = [a,b]()
	{
		a = b = 50;
		cout << "a:" << a << endl;
		cout << "b:" << b << endl;
	};
	lam();
	cout << "a:" << a << endl;
	cout << "b:" << b << endl;
	
	return 0;
}

 加上mutable关键字：

注意：

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

->returntype：

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

{statement}：

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

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

3.lambda捕捉列表说明

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

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

int main()
{
	int a = 100;
	int b = 200;
	int sum = 0;
	auto lam1 = [a]()
	{
		cout << a << endl;
	};
	lam1();

	return 0;
}

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

int main()
{
	int a = 100;
	int b = 200;
	int sum = 0;
	auto lam1 = [=]()
	{
		cout << a << endl;
		cout << b << endl;
	};
	lam1();
	return 0;
}

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

int main()
{
	int a = 100;
	int b = 200;
	int sum = 0;
	auto lam1 = [&a]()
	{
		a = 500;
	};
	lam1();
	cout << "a:" << a;
	return 0;
}

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

int main()
{
	int a = 100;
	int b = 200;
	int sum = 0;
	auto lam1 = [&]()
	{
		a = b = 50;
	};
	lam1();
	cout << "a:" << a << endl;
	cout << "b:" << b << endl;
	
	return 0;
}

 

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

class Test
{
public:
	Test(int a)
		:_a(a)
	{
	}

	void operator()()
	{
		//捕捉this指针之后，无需使用this类指定成员，可以直接访问类成员
		auto Prin_a = [this]() {cout <<"class Teat::_a:" << _a << endl; };
		Prin_a();
	}

private:
	int _a;
	
};

int main()
{
	Test T(100);
	T();
	return 0;
}

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

三.函数对象与lambda表达式

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

class Rate
{
public:
	Rate(double rate) : _rate(rate)
	{}
	double operator()(double money, int year)
	{
		return money * _rate * year;
	}
private:
	double _rate;
};
int main()
{
	// 函数对象
	double rate = 0.49;
	Rate r1(rate);
	r1(10000, 2);
	// lamber
	auto r2 = [=](double monty, int year)->double {return monty * rate * year;
	};
	r2(10000, 2);
	return 0;
}

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

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

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

四.包装器

1.function包装器

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

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函数模板实例化了三份，产生这个的原因是，即使这三个可调用对象的功能都是一模一样的，但是由于三个可调用对象，一个是函数，一个是类对象，一个是lambda表达式，是三种不同的类型，所以也就导致了模板在实例化的时候，会实例化出三份useF函数。

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

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

包装上述可调用对象：

#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()
{
	function<double(double)> func1 = f;
	function<double(double)> func2 = Functor();
	function<double(double)> func3 = [](double d) {return d / 1; };
	
	useF<function<double(double)>, double>(func1, 11.11);
	useF<function<double(double)>, double>(func2, 11.11);
	useF<function<double(double)>, double>(func3, 11.11);

	return 0;
}

2.包装类的成员函数

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

class Add
{
public:
	Add(int a)
		:_a(a)
	{}
	int add(int b)
	{
		return _a + b;
	}
	static int s_add(int a, int b)
	{
		return a + b;
	}
private:
	int _a;
};

int main()
{
	//包装非静态成员函数,用对象构建
	function<int(Add, int)> fun1 = &Add::add;
	cout << fun1(Add(10), 30) << endl;
	
	//包装非静态成员函数，用对象指针构建
	Add add(10);
	function<int(Add*, int)> fun3 = &Add::add;
	cout << fun3(&add, 30) << endl;

	//包装静态成员函数
	function<int(int,int)> fun2 = Add::s_add;
	cout << fun2(10, 30) << endl;

	return 0;
}

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

 五.bind

std::bind函数定义在头文件<functional>中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（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为第二个参数，以此类推。

1.调整参数位置

void Plus(int a, int b)
{
	cout << a << " " << b << endl;
}

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

	return 0;
}

2.减少函数参数

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

 class Add
{
public:
	Add(int c)
		:_c(c)
	{}
	int add(int a,int b)
	{
		return (a + b) * _c;
	}
private:
	int _c;
};

int main()
{
	//包装非静态成员函数,用对象构建
	function<int(Add, int,int)> fun1 = &Add::add;
	cout << fun1(Add(10), 3,2) << endl;

	//包装非静态成员函数,用对象构建
	//指定一个参数Add(10)作为参数，剩余参数正常传参
	function<int(int,int)> fun2 = bind(&Add::add, Add(10), placeholders::_1, placeholders::_2);
	cout << fun2(3,2) << endl;
	
	return 0;
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

c++_learning-模板元编程

c++_learning-模板元编程

模板元编程 元编程&#xff1a;元函数&#xff1a;定义&#xff1a;数值元函数&#xff1a;编译期间&#xff0c;能够被调用的类模板&#xff1a;constexpr修饰的函数&#xff1a;constexpr修饰的变量模板&#xff1a; 类型元函数&#xff1a;元函数总结&#xff1a; 混合元编程…
阅读更多...
C++基础——内存分区模型

C++基础——内存分区模型

1 概述 C程序在执行是&#xff0c;将内存大致分为4个区域&#xff1a; 代码区&#xff1a;用于存放二进制代码&#xff0c;由操作系统进行管理全局区&#xff1a;存放全局变量和静态变量及常量栈区&#xff1a;由编译器自动分配释放&#xff0c;存放函数的参数、局部变量等堆…
阅读更多...
电脑版便签软件下载用哪个?

电脑版便签软件下载用哪个?

在面对每天繁忙的工作日程&#xff0c;电脑是许多上班族不可或缺的工作助手&#xff0c;而一款得心应手的电脑便签软件&#xff0c;更是可以帮助大家记录、提醒、督促各项任务按时完成的得力助手。那么&#xff0c;究竟在众多的电脑便签软。件中&#xff0c;哪一位能够真正成为…
阅读更多...
你真的理解“感受野”了吗？

你真的理解“感受野”了吗？

大家好啊&#xff0c;我是董董灿。 在卷积神经网络中&#xff0c;有一个非常重要且绕不开的概念叫做卷积的“感受野”。 我刚开始学习卷积的时候&#xff0c;仅仅把“感受野”理解为感受视野&#xff0c;没错就是文字上的理解。 但随着后来工作的深入&#xff0c;慢慢发现感…
阅读更多...
pytorch的安装【全官网流程】

pytorch的安装【全官网流程】

1.准备python环境 python环境需要看pytorch上说明的版本本文用的是python3.9 conda create -n pytorch39 python3.92.安装pytorch【要使用GPU的先安装步骤3的CUDA在安装这个】 pytorch官方地址 &#xff08;1&#xff09;官方指出了python版本&#xff1a; &#xff08;2…
阅读更多...
微信私域怎么高效转化？看看这款系统！

微信私域怎么高效转化？看看这款系统！

在今天的数字化时代&#xff0c;私域流量已经成为企业与个人创业者获取竞争优势的重要手段。而微信作为中国最大的社交平台之一&#xff0c;其私域流量的价值不言而喻。那么&#xff0c;如何才能轻松玩转微信私域流量呢&#xff1f;接下来&#xff0c;我们将为你介绍一款强大的…
阅读更多...
设计模式：抽象工厂模式（C#、JAVA、JavaScript、C++、Python、Go、PHP）

设计模式：抽象工厂模式（C#、JAVA、JavaScript、C++、Python、Go、PHP）

大家好&#xff01;本节主要介绍设计模式中的抽象工厂模式。 简介&#xff1a; 抽象工厂模式&#xff0c;它是所有形态的工厂模式中最为抽象和最具一般性的一种形态。它用于处理当有多个抽象角色时的情况。抽象工厂模式可以向客户端提供一个接口&#xff0c;使客户端在不必指…
阅读更多...
TCP/IP(十九)TCP 实战抓包分析(三)TCP 第一次握手 SYN 丢包

TCP/IP(十九)TCP 实战抓包分析(三)TCP 第一次握手 SYN 丢包

一 TCP 三次握手异常情况实战分析 说明&#xff1a; 本文是TCP 三次握手异常系列之一 ① 异常场景 接下里我用三个实验案例,带大家一起探究探究这三种异常关注&#xff1a; 如何刻意练习模拟上述场景 以及 wireshark现象 ② 实验环境 ③ 实验一&#xff1a;TCP 第一次握…
阅读更多...
STM32F407在RAM中执行程序

STM32F407在RAM中执行程序

STM32F407在flash中执行代码的速度比在ram中执行代码的速度快。因为STM32F407有一颗“自适应实时存储器加速器”&#xff0c;这里不讨论ART Accelerator的加速方案。 把代码放在RAM中执行纯粹是为了学习。 将个别函数的代码放到RAM中运行 使用自己编写的链接脚本(sct文件)。 …
阅读更多...
《论文阅读28》OGMM

《论文阅读28》OGMM

一、论文 研究领域&#xff1a; 点云配准 | 有监督 部分重叠论文&#xff1a;Overlap-guided Gaussian Mixture Models for Point Cloud Registration WACV 2023 二、概述 概率3D点云配准方法在克服噪声、异常值和密度变化方面表现出有竞争力的性能。本文将点云对的配准问题…
阅读更多...
【计算机网络原理】初始网络基础

【计算机网络原理】初始网络基础

文章目录 1. 网络发展史1.1 单机时代1.2 网络互连局域网 LAN广域网 WAN 2. 网络通信基础2.1 IP 地址2.2 端口号2.3 协议2.4 五元组2.5 协议分层2.5.1 OSI七层模型2.5.2 TCP/IP五层模型 2.6 封装和分用2.6.1 数据封装(发送方情况)2.6.2 数据分用(接收方情况) 总结 1. 网络发展史…
阅读更多...
这是不是你们都在找的免费又好用的配音网站？

这是不是你们都在找的免费又好用的配音网站？

随着人工智能技术的不断发展和普及&#xff0c;AI配音软件也越来越多地进入人们的视野。它可以帮助我们快速地将文字转换成语音&#xff0c;让我们的工作变得更加高效和便捷。在本文中&#xff0c;我将介绍一款非常实用而且免费的AI配音网站&#xff0c;超级简单好用&#xff0…
阅读更多...
C++string的使用

C++string的使用

CSDN的uu们&#xff0c;大家好。这里是C入门的第十六讲。 座右铭&#xff1a;前路坎坷&#xff0c;披荆斩棘&#xff0c;扶摇直上。 博客主页&#xff1a; 姬如祎 收录专栏&#xff1a;C专题 目录 1.构造函数 1.1 string() 1.2 string(const char* s) 1.3 string(const …
阅读更多...
Cinema 4D云渲染一分钟动画要多少钱？如何进行Cinema 4D云渲染？看完就懂了

Cinema 4D云渲染一分钟动画要多少钱？如何进行Cinema 4D云渲染？看完就懂了

&#xfeff;1.为什么Cinema 4D要使用云渲染&#xff1f; 近年来&#xff0c;Cinema 4D在实现视觉效果方面取得了很大的进展。但是&#xff0c;随着视觉效果的复杂化&#xff0c;渲染的工作量也相应增加&#xff0c;导致渲染时间变长。在这种情况下&#xff0c;云渲染平台就能…
阅读更多...
Linux嵌入式系统开发之路：从小白到大牛

Linux嵌入式系统开发之路：从小白到大牛

&#x1f482; 个人网站:【工具大全】【游戏大全】【神级源码资源网】&#x1f91f; 前端学习课程&#xff1a;&#x1f449;【28个案例趣学前端】【400个JS面试题】&#x1f485; 寻找学习交流、摸鱼划水的小伙伴&#xff0c;请点击【摸鱼学习交流群】 嵌入式系统开发是一个充…
阅读更多...
Spring framework Day22:Aware接口

Spring framework Day22:Aware接口

前言 在Spring框架中&#xff0c;有许多接口和类都有一个非常重要的作用——让我们能够更方便地构建应用程序和管理组件。其中&#xff0c;Aware接口就是其中一个非常重要的接口之一。通过实现该接口&#xff0c;我们可以让Spring容器感知到特定的组件和资源&#xff0c;并进行…
阅读更多...
媒体转码和输出软件：Media Encoder 2024中文版

媒体转码和输出软件：Media Encoder 2024中文版

想要高效地转码、优化输出吗&#xff1f;那就来尝试全新的Media Encoder 2024吧&#xff01;Media Encoder是Adobe公司出品的一款媒体转码和输出软件&#xff0c;可以帮助您快速、高效地将多种格式的视频和音频转换为所需的输出格式。 全新的Media Encoder 2024提供了更加智能…
阅读更多...
【CANoe】XML Test Module使用实例

【CANoe】XML Test Module使用实例

文章目录 一、实操步骤1、增加XML Test Module节点2、配置XML Test Module节点3、XML Test Module节点增加CAPL脚本(.can文件)4、文件夹结构5、使用仿真节点开始测试6、测试结果与测试报告7、同理&#xff0c;在Test Setup也可如此操作 一、实操步骤 1、增加XML Test Module节…
阅读更多...
使用conda install一直卡在solving environment的解决方法

使用conda install一直卡在solving environment的解决方法

使用国内镜像源&#xff0c;但install仍旧一直卡在solving environment&#xff0c;超过10分钟就不用等了&#xff1b; 检查C:\Users\UserName 路径下的.condarc文件 将这个defaults这一行删掉即可
阅读更多...
【Linux-常用命令-基础命令-复制-copy-命令-笔记】

【Linux-常用命令-基础命令-复制-copy-命令-笔记】

【Linux-常用命令-基础命令-复制文件-copy-命令-笔记】 1、前言2、操作3、自己的实践 1、前言 最近&#xff0c;在使用Linux的时&#xff0c;使用相关基础命令是&#xff0c;总是容易忘记&#xff0c;上网一搜&#xff0c;大部分都写的比较繁琐&#xff0c;我就找下复制命令&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023