C++11（lambda和包装器）

1. lambda

1.1 lambda表达式语法

  1. lambda 表达式本质是⼀个匿名函数对象，跟普通函数不同的是它可以定义在函数内部。lambda 表达式语法使⽤层⽽⾔没有类型，所以我们⼀般是⽤auto或者模板参数定义的对象去接收 lambda 对象。
  2. lambda 表达式的格式： [capture-list] (parameters)-> return type { function boby }
  3. [capture-list]：捕捉列表，该列表总是出现在 lambda 函数的开始位置，编译器根据[]来判断接下来的代码是否为 lambda 函数，捕捉列表能够捕捉上下⽂中的变量供 lambda 函数使⽤，捕捉列表可以传值和传引⽤捕捉，具体细节1.2中我们再细讲。捕捉列表为空也不能省略。
  4. (parameters)：参数列表，与普通函数的参数列表功能类似，如果不需要参数传递，则可以连同()⼀起省略
  5. -> return type：返回值类型，⽤追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。⼀般返回值类型明确情况下，也可省略，由编译器对返回类型进⾏推导。
  6. { function boby }：函数体，函数体内的实现跟普通函数完全类似，在该函数体内，除了可以使⽤其参数外，还可以使⽤所有捕获到的变量，函数体为空不能省略。
int main()
{
				// 匿名函数对象
	auto add1 = [](int x, int y)->int {return x + y; };
	//auto add1 = [](int x, int y){return x + y; };
	cout << add1(1, 2) << endl;

	// 1. 捕捉为空不能省略
	// 2. 参数为空可以省略
	// 3. 返回值可以省略，可以通过返回对象自动推导
	// 4. 函数体不能省略
	auto func1 = []
	{
		cout << "hello bit" << endl;
		return 0;
	};
	cout << func1() << endl;

	int a = 0, b = 1;
	auto swap1 = [](int& x, int& y)
	{
		int tmp = x;
      x = y;
		y = tmp;
	};
	swap1(a, b);
	cout << a << ":" << b << endl;

	return 0;
}

在这里插入图片描述

1.2 捕捉列表

  1. lambda 表达式中默认只能⽤ lambda 函数体和参数中的变量，如果想⽤外层作⽤域中的变量就需要进⾏捕捉
  2. 第⼀种捕捉⽅式是在捕捉列表中显式的传值捕捉和传引⽤捕捉，捕捉的多个变量⽤逗号分割。[x，y，&z]表示x和y值捕捉，z引⽤捕捉。
  3. 第⼆种捕捉⽅式是在捕捉列表中隐式捕捉，我们在捕捉列表写⼀个=表示隐式值捕捉，在捕捉列表写⼀个&表示隐式引⽤捕捉，这样我们 lambda 表达式中⽤了那些变量，编译器就会⾃动捕捉那些变量。
  4. 第三种捕捉⽅式是在捕捉列表中混合使⽤隐式捕捉和显式捕捉。[=,&x]表示其他变量隐式值捕捉，x引⽤捕捉；[&,x,y]表示其他变量引⽤捕捉，x和y值捕捉。当使⽤混合捕捉时，第⼀个元素必须是&或=，并且&混合捕捉时，后⾯的捕捉变量必须是值捕捉，同理=混合捕捉时，后⾯的捕捉变量必须是引⽤捕捉。
  5. lambda 表达式如果在函数局部域中，他可以捕捉 lambda 位置之前定义的变量，不能捕捉静态局部变量和全局变量，静态局部变量和全局变量也不需要捕捉， lambda 表达式中可以直接使⽤。这也意味着 lambda 表达式如果定义在全局位置，捕捉列表必须为空。
  6. 默认情况下， lambda 捕捉列表是被const修饰的，也就是说传值捕捉过来的对象不能修改，mutable加在参数列表的后⾯可以取消其常量性，也就说使⽤该修饰符后，传值捕捉的对象就可以修改了，但是修改还是形参对象，不会影响实参。使⽤该修饰符后，参数列表不可省略(即使参数为空)。
int x = 0;
// 捕捉列表必须为空，因为全局变量不用捕捉就可以用，没有可被捕捉的变量
auto func = []()
{
	x++;
};

int main()
{
	// 只能用当前lambda局部域和捕捉的对象和全局对象
	int a = 0, b = 1, c = 2, d = 3;
	auto func1 = [a, &b]
	{
		// 值捕捉的变量不能修改，引用捕捉的变量可以修改
		//a++;
		b++;
		int ret = a + b;
		return ret;
	};
	cout << func1() << endl;

	// 隐式值捕捉
	// 用了哪些变量就捕捉哪些变量
	auto func2 = [=]
	{
		int ret = a + b + c;
		return ret;
	};
	cout << func2() << endl;

	// 隐式引用捕捉
	// 用了哪些变量就捕捉哪些变量
	auto func3 = [&]
	{
		a++;
		c++;
		d++;
	};
	func3();
	cout << a << " " << b << " " << c << " " << d << endl;

	// 混合捕捉
	auto func4 = [&, a, b]
	{
		//a++;
		//b++;
		c++;
		d++;
	};
	func4();
	cout << a << " " << b << " " << c << " " << d << endl;

	auto func5 = [=, &a, &b]
	{
		a++;
		b++;
		//c++;
		//d++;
	};
	func5();
	cout << a << " " << b << " " << c << " " << d << endl;

	// 局部的静态变量和全局变量不能捕捉，也不需要捕捉
	static int m = 0;

	func();
	auto func6 = []
	{
		int ret = x + m;
		return ret;
	};
	cout << func6() << endl;

	// 传值捕捉本质是一种拷贝，并且被const修饰了
	// mutable相当于去掉const属性，可以修改了
	// 但是修改了不会影响外面被捕捉的值，因为是一种拷贝
	auto func7 = [=]()mutable
	{
		a++;
		b++;
		c++;
		d++;
		return a + b + c + d;
	};
	cout << func7() << endl;
	cout << a << " " << b << " " << c << " " << d << endl;

	return 0;
}

在这里插入图片描述

class A
{
public:
	void f()
	{
		int i = 1;
		// 成员函数内部，想用成员变量，可以捕获this
		auto add1 = [this, i](int x, int y)->int {return x + y + i + _a + _b; };
		cout << add1(1, 2) << endl;
	}

private:
	int _a = 1;
	int _b = 2;
};

int main()
{
	A().f();
}

在这里插入图片描述

1.3 lambda的应用

  1. 在学习 lambda 表达式之前，我们使⽤的可调⽤对象只有函数指针和仿函数对象，函数指针的类型定义起来⽐较麻烦，仿函数要定义⼀个类，相对会⽐较麻烦。使⽤ lambda 去定义可调⽤对象，既简单⼜⽅便。
  2. lambda 在很多其他地⽅⽤起来也很好⽤。⽐如线程中定义线程的执⾏函数逻辑，智能指针中定制删除器等， lambda 的应⽤还是很⼴泛的，以后我们会不断接触到。
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;
	}
};

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

	// 类似这样的场景，我们实现仿函数对象或者函数指针支持商品中
	// 不同项的比较，相对还是比较麻烦的，那么这里的lambda就很好用了
	sort(v.begin(), v.end(), ComparePriceLess());
	sort(v.begin(), v.end(), ComparePriceGreater());

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

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

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

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

1.4 lambda的原理

  1. lambda 的原理和范围for很像，编译后从汇编指令层的⻆度看，压根就没有 lambda 和范围for这样的东西。范围for底层是迭代器，⽽lambda底层是仿函数对象，也就说我们写了⼀个 lambda 以后，编译器会⽣成⼀个对应的仿函数的类。
  2. 仿函数的类名是编译器按⼀定规则⽣成的，保证不同的 lambda ⽣成的类名不同， lambda 参数/返回类型/函数体就是仿函数operator()的参数/返回类型/函数体， lambda 的捕捉列表本质是⽣成的仿函数类的成员变量，也就是说捕捉列表的变量都是 lambda 类构造函数的实参，当然隐式捕捉，编译器要看使⽤哪些就传那些对象。
  3. 上⾯的原理，我们可以透过汇编层了解⼀下，下⾯的汇编层代码印证了上⾯的原理。
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;

	// lambda
	auto r2 = [rate](double money, int year) {
		return money * rate * year;
		};

	// 函数对象
	Rate r1(rate);
	r1(10000, 2);
	r2(10000, 2);

	auto func1 = [] {
		cout << "hello world" << endl;
		};
	func1();

	return 0;
}

在这里插入图片描述

2. 包装器

2.1 function

template <class T>
class function; // undefined

template <class Ret, class... Args>
class function<Ret(Args...)>;
  1. std::function是⼀个类模板，也是⼀个包装器。std::function的实例对象可以包装存储其他的可以调⽤对象，包括函数指针、仿函数、lambda 、bind表达式等，存储的可调⽤对象被称为std::function的⽬标。若std::function不含⽬标，则称它为空。调⽤空std::function的⽬标导致抛出std::bad_function_call异常
  2. 以上是function 的原型，他被定义< functional >头⽂件中。std::function-cppreference.com是function的官⽅⽂件链接。
  3. 函数指针、仿函数、lambda 等可调⽤对象的类型各不相同，std::function 的优势就是统⼀类型，对他们都可以进⾏包装，这样在很多地⽅就⽅便声明可调⽤对象的类型，下⾯的第二个代码样例展示了std::function 作为map的参数，实现字符串和可调⽤对象的映射表功能。
#include <functional>

int f(int a, int b)
{
	return a + b;
} 

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

class Plus
{
public:
	Plus(int n = 10)
		: _n(n)
	{}
	
	static int plusi(int a, int b)
	{
		return a + b;
	}
	
	double plusd(double a, double b)
	{
		return (a + b) * _n;
	}
private:
	int _n;
};

int main()
{
	// 包装各种可调用对象
	function<int(int, int)> f1(f);
	function<int(int, int)> f2 = Functor();
	function<int(int, int)> f3 = [](int a, int b) {return (a + b) * 20; };

	cout << f1(1, 2) << endl;
	//cout << f1.operator()(1, 2) << endl;
	cout << f2(1, 2) << endl;
	cout << f3(1, 2) << endl;

	// 包装静态成员函数
	// 成员函数要指定类域并且前面加&才能获取地址
	// 静态成员函数可以不加&，但是建议都加上&
	function<int(int, int)> f4 = &Plus::plusi;
	cout << f4(1, 1) << endl;

	// 包装普通成员函数
	// 普通成员函数还有一个隐含的this指针参数
	// 绑定时传对象或者对象的指针过去都可以
	function<double(Plus*, double, double)> f5 = &Plus::plusd;
	Plus pd;
	cout << f5(&pd, 1.1, 1.1) << endl;

	function<double(Plus, double, double)> f6 = &Plus::plusd;
	cout << f6(pd, 1.1, 2.2) << endl;

	function<double(Plus&&, double, double)> f7 = &Plus::plusd;
	cout << f7(move(pd), 1.1, 1.1) << endl;
	cout << f7(Plus(), 1.1, 1.1) << endl;

	return 0;
}

在这里插入图片描述

150. 逆波兰表达式求值 - ⼒扣（LeetCode）

// 传统⽅式的实现
class Solution {
public:
	int evalRPN(vector<string>& tokens) {
		stack<int> st;
		for (auto& str : tokens)
		{
			if (str == "+" || str == "-" || str == "*" || str == "/")
			{
				int right = st.top();
				st.pop();
				int left = st.top();
				st.pop();
				switch (str[0])
				{
				case '+':
					st.push(left + right);
					break;
				case '-':
					st.push(left - right);
					break;
				case '*':
					st.push(left * right);
					break;
				case '/':
					st.push(left / right);
					break;
				}
			} 
			else
			{
			st.push(stoi(str));
			}
		} 
		return st.top();
	}
};

// 使⽤map映射string和function的⽅式实现
// 这种⽅式的最⼤优势之⼀是⽅便扩展，
// 假设还有其他运算，我们增加map中的映射即可
class Solution {
public:
	int evalRPN(vector<string>& tokens) {
		stack<int> st;
		map<string, function<int(int, int)>> opFuncMap =
		{
			{"+", [](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 (auto& str : tokens)
		{
			if (opFuncMap.count(str))
			{
				int right = st.top();
				st.pop();
				int left = st.top();
				st.pop();
				st.push(opFuncMap[str](left, right));
			}
			else
			{
				st.push(stoi(str));
			}
		}
		return st.top();
	}
};

2.2 bind

 simple(1)
 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);
  1. bind 是⼀个函数模板，它也是⼀个可调⽤对象的包装器，可以把它看做⼀个函数适配器，对接收的fn可调⽤对象进⾏处理后返回⼀个可调⽤对象。bind 可以⽤来调整参数个数和参数顺序。
  2. 调⽤bind的⼀般形式：auto newCallable = bind(callable,arg_list);其中newCallable本⾝是⼀个可调⽤对象，arg_list是⼀个逗号分隔的参数列表，对应给定的callable的参数。当我们调⽤newCallable时，newCallable会调⽤callable，并传给它arg_list中的参数。
  3. arg_list中的参数可能包含形如_n的名字，其中n是⼀个整数，这些参数是占位符，表示newCallable的参数，它们占据了传递给newCallable的参数的位置。数值n表示⽣成的可调⽤对象中参数的位置：_1为newCallable的第⼀个参数，_2为第⼆个参数，以此类推。_1/_2/_3…这些占位符放到placeholders的⼀个命名空间中。
#include<functional>

using placeholders::_1;
using placeholders::_2;
using placeholders::_3;

int Sub(int a, int b)
{
	return (a - b) * 10;
}

int SubX(int a, int b, int c)
{
	return (a - b - c) * 10;
}

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

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

int main()
{
	auto sub1 = bind(Sub, _1, _2);
	cout << sub1(10, 5) << endl;

	// bind 本质返回的是一个仿函数对象
	// 调整参数顺序（不常用）
	// _1代表第一个实参
	// _2代表第二个实参
	// ...

	// 在这里，_1代表第一个实参10，_2代表第二个实参5
	auto sub2 = bind(Sub, _2, _1);
	cout << sub2(10, 5) << endl;

	// 调整参数个数（常用）
	auto sub3 = bind(Sub, 6, _1);
	cout << sub3(5) << endl;

	auto sub4 = bind(Sub, _1, 6);
	//function<int(int)> sub4 = bind(Sub, _1, 6);
	cout << sub4(5) << endl;

	// 分别绑死第123个参数
	auto sub5 = bind(SubX, 5, _1, _2);
	cout << sub5(6, 7) << endl;

	auto sub6 = bind(SubX, _1, 5, _2);
	cout << sub6(6, 7) << endl;

	auto sub7 = bind(SubX, _1, _2, 5);
	cout << sub7(6, 7) << endl;

	// 成员函数对象进行绑死，就不需要每次都传递了
	function<double(Plus&&, double, double)> f6 = &Plus::plusd;
	Plus pd;
	cout << f6(move(pd), 1.1, 1.1) << endl;
	cout << f6(Plus(), 1.1, 1.1) << endl;
	
	// bind⼀般用于绑死⼀些固定参数
	function<double(double, double)> f7 = bind(&Plus::plusd, Plus(), _1, _2);
	cout << f7(1.1, 1.1) << endl;

	// 计算复利的lambda
	auto func1 = [](double rate, double money, int year)->double 
	{
		double ret = money;
		for (int i = 0; i < year; ++i)
		{
			ret += ret * rate;
		}
		return ret - money;
	};

	// 绑死一些参数，实现出支持不同年份和利率在相同金额下的复利
	function<double(double)> func3_1_5 = bind(func1, 0.015, _1, 3);
	function<double(double)> func5_2_5 = bind(func1, 0.025, _1, 5);
	function<double(double)> func10_3_5 = bind(func1, 0.035, _1, 10);
	function<double(double)> func20_4_5 = bind(func1, 0.045, _1, 20);

	cout << func3_1_5(1000000) << endl;
	cout << func5_2_5(1000000) << endl;
	cout << func10_3_5(1000000) << endl;
	cout << func20_4_5(1000000) << endl;

	return 0;
}

在这里插入图片描述

# c++
Logo
AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

cover

别让你的 Agent 一口吃成胖子：AI Agent 任务拆分的工程实践指南

avatar AI Agent技术社区
cover

AI Agent律师行业智能体的实践步骤

avatar AI Agent技术社区

MCP + 企业IM架构：AI Agent调用OA、ERP、MES时，身份和权限如何传递？

<think>我们只需要根据内容生成摘要，不超过150字。先理解文章核心：MCP+企业IM架构，AI Agent调用OA/ERP/MES时身份和权限传递。要点：IM从消息入口变任务入口；MCP解决连接，但不解决权限；需要五层身份映射；权限分层（可见性、调用、数据范围、确认）；建议组合MCP+API网关。摘要需简洁。 参考生成： "本文探讨MCP与企业IM集成中AI Agent调用业务系统时的身份权

avatar AI Agent技术社区