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

C++11 lambda表达式、包装器、Bind绑定

news 来源：原创 2025/5/16 12:59:10

Hello！大家早上中午晚上好！！今天来复习C++11三个新加的特性！！

一、lambda 表达式

1.1什么是lambda表达式？

语法：[捕捉列表]（参数列表）->返回值{函数体}；

捕捉列表：捕捉上下文的变量供lambda函数使用可省略；

参数列表：与普通函数的参数列表一样，如果没有可省略；

->：可省略；

返回值：如果为空或已确定返回类型，可省略；

函数体：如果没有要写的也可省略；

最简洁的lambda表达式： []{};

1.2 写一lambda表达式用来比较两个数的大小：

int main()
{
	int x = 10;
	int y = 20;
	auto f1 = [](int x, int y)->bool {return x > y; };
	cout << f1(x, y) << endl;
	cout << f1(y, x) << endl;
	return 0;
}

lambda表达式相当于一个局部的匿名函数对象

1.3lambda表达式的作用

lambda表达式与仿函数比较：

class foods
{
public:
	foods(int price,const char*name,int id)
		:_price(price),_name(name),_id(id)
	{

	}
	int _price;//价格
	const char* _name;//名字
	int _id;//编号
};

struct priceLess
{
	bool operator()(foods& f1, foods& f2)
	{
		return f1._price < f2._price;
	}
};
struct priceGreater
{
	bool operator()(foods&f1,foods&f2)
	{
		return f1._price > f2._price;
	}
};
int main()
{
	foods rice(10, "米饭", 101);
	foods chicken(20, "鸡肉", 102);
	foods fish(30, "鱼",103);
	//使用仿函数
	//比较谁价格更低
	priceLess less;
	cout << less(rice, chicken) << endl; 
	//比较谁价格高
	priceGreater great;
	cout << great(rice, fish) << endl;

	//使用lambda表达式
	auto f1 = [](foods&f1,foods&f2)->bool {return f1._price < f2._price;};
	cout << f1(rice, chicken) << endl;
	auto f2 = [](foods& f1, foods& f2)->bool {return f1._price > f2._price; };
	cout << f2(rice, fish) << endl;
	return 0;
}

lambda表达式使用起来更简洁方便灵活，仿函数的定义写的太死板，且代码太繁琐；假设要比较foods类的id又要定义一个比较id的类，假设要比较foods类的name，又要定义一个比较name的类；而lambda表达式直接写就行；

1.4lambda表达式的实现原理

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

二、包装器

2.1什么是包装器？

包装器是函数适配器，用来包装可调用对象，包装器实质是一个模版：

包装器的头文件： <functional>

其中Ret是返回类型，Args...是可变参数；

2.2包装器的使用

一个简单的包装器使用：

#include<functional>
//函数指针
int fun1(int x, int y)
{
	return x + y;
}
//仿函数
class fun2
{
public:
	double operator()(double x, double y)
	{
		return x + y;
	}
};
//类
class A
{
public:
	int add(int x, int y)//非静态成员函数
	{
		return x * y;
	}
	static void print()//静态成员函数
	{
		cout << "我是一个类成员静态函数" << endl;
	}
};
int main()
{
	//包装一个函数指针
	function<int(int, int)> func1 = fun1;
	cout << fun1(3, 3) << endl;
	//包装一个仿函数
	function<double(double, double)> func2 = fun2();
	cout << func2(3.3, 4.4) << endl;
	//包装一个非静态成员函数 
	function<int(A, int, int)> func3 = &A::add;
	cout << func3(A(), 4, 4) << endl;
	//包装一个静态成员函数
	function<void()> func4 = &A::print;
	func4();
	//包装一个lambda表达式
	function<string(int)> func5 = [](int x)->string {string s1 = "你好"; s1 += x; return s1; };
	cout << func5(88) << endl;
	return 0;
}

注意：非静态类型成员函数必须取地址，静态成员函数可以不取地址

2.3包装器的作用

包装器的作用就是用来包装可调用对象并统一可调用对象的类型，方便管理！

理解：

使用包装器后：

只要返回类型，参数列表类型一样，包装器可以把所有可调用对象的类型统一！方便管理！！

三、bind绑定

3.1原形

可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。

3.2使用

int Sub(int x, int y)
{
	return x - y;
}
int main()
{
    //绑定第一个参数传_1，第二个参数传_2（与原形一样）
	function<int(int, int)> func1 = bind(Sub, placeholders:: _1, placeholders:: _2);
	cout << func1(3, 5) << endl;

    //绑定第一个参数传_1,第二个参数传_2 (交换位置)
	function<int(int, int)>func2 = bind(Sub, placeholders::_2, placeholders::_1);
	cout << func2(3, 5) << endl;

    //绑定第一个参数为5，第二个参数为6
	function<int(int, int)>func3 = bind(Sub, 5,6);
	cout << func3(3,5) << endl;

	return 0;
}