【C++11】lambda表达式 | 包装器

一.lambda表达式

1.lambda表达式概念

ambda表达式是一个匿名函数，恰当使用lambda表达式可以让代码变得简洁，并且可以提高代码的可读性。

举个例子

商品类Goods的定义如下：

struct Goods
{
	string _name;  //名字
	double _price; //价格
	int _num;      //数量
};

现在要对若干商品分别按照价格和数量进行升序、降序排序。

• 要对一个数据集合中的元素进行排序，可以使用sort函数，但由于这里待排序的元素为自定义类型，因此需要用户自行定义排序时的比较规则。
• 要控制sort函数的比较方式常见的有两种方法，一种是对商品类的的()运算符进行重载，另一种是通过仿函数来指定比较的方式。
• 显然通过重载商品类的()运算符是不可行的，因为这里要求分别按照价格和数量进行升序、降序排序，每次排序就去修改一下比较方式是很笨的做法。

所以这里选择传入仿函数来指定排序时的比较方式。比如：

struct ComparePriceLess
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._price < g2._price;
	}
};
struct ComparePriceGreater
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._price > g2._price;
	}
};
struct CompareNumLess
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._num < g2._num;
	}
};
struct CompareNumGreater
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._num > g2._num;
	}
};
int main()
{
	vector<Goods> v = { { "苹果", 2.1, 300 }, { "香蕉", 3.3, 100 }, { "橙子", 2.2, 1000 }, { "菠萝", 1.5, 1 } };
	sort(v.begin(), v.end(), ComparePriceLess());    //按价格升序排序
	sort(v.begin(), v.end(), ComparePriceGreater()); //按价格降序排序
	sort(v.begin(), v.end(), CompareNumLess());      //按数量升序排序
	sort(v.begin(), v.end(), CompareNumGreater());   //按数量降序排序
	return 0;
}

仿函数确实能够解决这里的问题，但可能仿函数的定义位置可能和使用仿函数的地方隔得比较远，这就要求仿函数的命名必须要通俗易懂，否则会降低代码的可读性。

对于这种场景就比较适合使用lambda表达式。比如：

int main()
{
	vector<Goods> v = { { "苹果", 2.1, 300 }, { "香蕉", 3.3, 100 }, { "橙子", 2.2, 1000 }, { "菠萝", 1.5, 1 } };
	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._num < g2._num;
	}); //按数量升序排序
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)
	{
		return g1._num > g2._num;
	}); //按数量降序排序
	return 0;
}

这样一来，每次调用sort函数时只需要传入一个lambda表达式指明比较方式即可，阅读代码的人一看到lambda表达式就知道本次排序的比较方式是怎样的，提高了代码的可读性。

2.lambda表达式语法

lambda表达式书写格式：

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

lambda表达式各部分说明

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

lambda函数的参数列表和返回值类型都是可选部分，但捕捉列表和函数体是不可省略的，因此最简单的lambda函数如下：

int main()
{
	[]{}; //最简单的lambda表达式
	return 0;
}

该lambda函数不能做任何事情。

捕获列表说明

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

• [var]：表示值传递方式捕捉变量var。
• [=]：表示值传递方式捕获所有父作用域中的变量（成员函数包括this指针）。
• [&var]：表示引用传递捕捉变量var。
• [&]：表示引用传递捕捉所有父作用域中的变量（成员函数包括this指针）。
• [this]：表示值传递方式捕捉当前的this指针。

说明一下：

• 父作用域指的是包含lambda函数的语句块。
• 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。比如[=, &a, &b]。
• 捕捉列表不允许变量重复传递，否则会导致编译错误。比如[=, a]重复传递了变量a。
• 在块作用域以外的lambda函数捕捉列表必须为空，即全局lambda函数的捕捉列表必须为空。
• 在块作用域中的lambda函数仅能捕捉父作用域中的局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。
• lambda表达式之间不能相互赋值，即使看起来类型相同。

3.lambda表达式交换两个数

如果要用lambda表达式交换两个数，可以有以下几种写法：

标准写法

参数列表中包含两个形参，表示需要交换的两个数，注意需要以引用的方式传递。比如：

int main()
{
	int a = 10, b = 20;
	auto Swap = [](int& x, int& y)->void
	{
		int tmp = x;
		x = y;
		y = tmp;
	};
	Swap(a, b); //交换a和b
	return 0;
}

说明一下：

• lambda表达式是一个匿名函数，该函数无法直接调用，如果想要直接调用，可借助auto将其赋值给一个变量，此时这个变量就可以像普通函数一样使用。
• lambda表达式的函数体在格式上并不是必须写成一行，如果函数体太长可以进行换行，但换行后不要忘了函数体最后还有一个分号。

利用捕捉列表进行捕捉

以引用的方式捕捉所有父作用域中的变量，省略参数列表和返回值类型。比如：

int main()
{
	int a = 10, b = 20;
	auto Swap = [&]
	{
		int tmp = a;
		a = b;
		b = tmp;
	};
	Swap(); //交换a和b
	return 0;
}

这样一来，调用lambda表达式时就不用传入参数了，但实际我们只需要用到变量a和变量b，没有必要把父作用域中的所有变量都进行捕捉，因此也可以只对父作用域中的a、b变量进行捕捉。比如：

int main()
{
	int a = 10, b = 20;
	auto Swap = [&a, &b]
	{
		int tmp = a;
		a = b;
		b = tmp;
	};
	Swap(); //交换a和b
	return 0;
}

说明一下： 实际当我们以[&]或[=]的方式捕获变量时，编译器也不一定会把父作用域中所有的变量捕获进来，编译器可能只会对lambda表达式中用到的变量进行捕获，没有必要把用不到的变量也捕获进来，这个主要看编译器的具体实现。

传值方式捕捉？

如果以传值方式进行捕捉，那么首先编译不会通过，因为传值捕获到的变量默认是不可修改的，如果要取消其常量性，就需要在lambda表达式中加上mutable，并且此时参数列表不可省略。比如：

int main()
{
	int a = 10, b = 20;
	auto Swap = [a, b]()mutable
	{
		int tmp = a;
		a = b;
		b = tmp;
	};
	Swap(); //交换a和b？
	return 0;
}

但由于这里是传值捕捉，lambda函数中对a和b的修改不会影响外面的a、b变量，与函数的传值传参是一个道理，因此这种方法无法完成两个数的交换。

4.lambda表达式底层原理

lambda表达式的底层原理

实际编译器在底层对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的。函数对象就是我们平常所说的仿函数，就是在类中对()运算符进行了重载的类对象。

下面编写了一个Add类，该类对()运算符进行了重载，因此Add类实例化出的add1对象就叫做函数对象，add1可以像函数一样使用。然后我们编写了一个lambda表达式，并借助auto将其赋值给add2对象，这时add1和add2都可以像普通函数一样使用。比如：

class Add
{
public:
	Add(int base)
		:_base(base)
	{}
	int operator()(int num)
	{
		return _base + num;
	}
private:
	int _base;
};
int main()
{
	int base = 1;

	//函数对象
	Add add1(base);
	add1(1000);

	//lambda表达式
	auto add2 = [base](int num)->int
	{
		return base + num;
	};
	add2(1000);
	return 0;
}

调试代码并转到反汇编，可以看到：

• 在创建函数对象add1时，会调用Add类的构造函数。
• 在使用函数对象add1时，会调用Add类的()运算符重载函数。

如下图：

观察lambda表达式时，也能看到类似的代码：

• 借助auto将lambda表达式赋值给add2对象时，会调用类的构造函数。
• 在使用add2对象时，会调用类的()运算符重载函数。

如下图：

本质就是因为lambda表达式在底层被转换成了仿函数。

• 当我们定义一个lambda表达式后，编译器会自动生成一个类，在该类中对()运算符进行重载，实际lambda函数体的实现就是这个仿函数的operator()的实现。
• 在调用lambda表达式时，参数列表和捕获列表的参数，最终都传递给了仿函数的operator()。

lambda表达式和范围for是类似的，它们在语法层面上看起来都很神奇，但实际范围for底层就是通过迭代器实现的，lambda表达式底层的处理方式和函数对象是一样的。

lambda表达式之间不能相互赋值

lambda表达式之间不能相互赋值，就算是两个一模一样的lambda表达式。

• 因为lambda表达式底层的处理方式和仿函数是一样的，在VS下，lambda表达式在底层会被处理为函数对象，该函数对象对应的类名叫做。
• 类名中的uuid叫做通用唯一识别码（Universally Unique Identifier），简单来说，uuid就是通过算法生成一串字符串，保证在当前程序当中每次生成的uuid都不会重复。
• lambda表达式底层的类名包含uuid，这样就能保证每个lambda表达式底层类名都是唯一的。

因此每个lambda表达式的类型都是不同的，这也就是lambda表达式之间不能相互赋值的原因，我们可以通过typeid(变量名).name()的方式来获取lambda表达式的类型。比如：

int main()
{
	int a = 10, b = 20;
	auto Swap1 = [](int& x, int& y)->void
	{
		int tmp = x;
		x = y;
		y = tmp;
	};
	auto Swap2 = [](int& x, int& y)->void
	{
		int tmp = x;
		x = y;
		y = tmp;
	};
	cout << typeid(Swap1).name() << endl; //class 
	cout << typeid(Swap2).name() << endl; //class 
	return 0;
}

可以看到，就算是两个一模一样的lambda表达式，它们的类型都是不同的。

说明一下： 编译器只需要保证每个lambda表达式底层对应类的类名不同即可，并不是每个编译器都会将lambda表达式底层对应类的类名处理成，这里只是以VS为例。

二.包装器

1.function包装器

①function包装器介绍

function包装器

function是一种函数包装器，也叫做适配器。它可以对可调用对象进行包装，C++中的function本质就是一个类模板。

function类模板的原型如下：

template <class T> function;     // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;

模板参数说明：

• Ret：被包装的可调用对象的返回值类型。
• Args…：被包装的可调用对象的形参类型。

包装示例

function包装器可以对可调用对象进行包装，包括函数指针（函数名）、仿函数（函数对象）、lambda表达式、类的成员函数。比如：

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()
{
	//1、包装函数指针（函数名）
	function<int(int, int)> func1 = f;
	cout << func1(1, 2) << endl;

	//2、包装仿函数（函数对象）
	function<int(int, int)> func2 = Functor();
	cout << func2(1, 2) << endl;

	//3、包装lambda表达式
	function<int(int, int)> func3 = [](int a, int b){return a + b; };
	cout << func3(1, 2) << endl;

	//4、类的静态成员函数
	//function func4 = Plus::plusi;
	function<int(int, int)> func4 = &Plus::plusi; //&可省略
	cout << func4(1, 2) << endl;

	//5、类的非静态成员函数
	function<double(Plus, double, double)> func5 = &Plus::plusd; //&不可省略
	cout << func5(Plus(), 1.1, 2.2) << endl;
	return 0;
}

注意事项：

• 包装时指明返回值类型和各形参类型，然后将可调用对象赋值给function包装器即可，包装后function对象就可以像普通函数一样使用了。
• 取静态成员函数的地址可以不用取地址运算符“&”，但取非静态成员函数的地址必须使用取地址运算符“&”。
• 包装非静态的成员函数时需要注意，非静态成员函数的第一个参数是隐藏this指针，因此在包装时需要指明第一个形参的类型为类的类型。

②function包装器统一类型

对于以下函数模板useF：

• 传入该函数模板的第一个参数可以是任意的可调用对象，比如函数指针、仿函数、lambda表达式等。
• useF中定义了静态变量count，并在每次调用时将count的值和地址进行了打印，可判断多次调用时调用的是否是同一个useF函数。

代码如下：

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;

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

由于函数指针、仿函数、lambda表达式是不同的类型，因此useF函数会被实例化出三份，三次调用useF函数所打印count的地址也是不同的。

• 但实际这里根本没有必要实例化出三份useF函数，因为三次调用useF函数时传入的可调用对象虽然是不同类型的，但这三个可调用对象的返回值和形参类型都是相同的。
• 这时就可以用包装器分别对着三个可调用对象进行包装，然后再用这三个包装后的可调用对象来调用useF函数，这时就只会实例化出一份useF函数。
• 根本原因就是因为包装后，这三个可调用对象都是相同的function类型，因此最终只会实例化出一份useF函数，该函数的第一个模板参数的类型就是function类型的。

代码如下：

int main()
{
	//函数名
	function<double(double)> func1 = func;
	cout << useF(func1, 11.11) << endl;

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

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

这时三次调用useF函数所打印count的地址就是相同的，并且count在三次调用后会被累加到3，表示这一个useF函数被调用了三次。

③function包装器的意义

• 将可调用对象的类型进行统一，便于我们对其进行统一化管理。
• 包装后明确了可调用对象的返回值和形参类型，更加方便使用者使用。

2.bind包装器

①bind包装器介绍

bind包装器

bind也是一种函数包装器，也叫做适配器。它可以接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表，C++中的bind本质是一个函数模板。

bind函数模板的原型如下：

template <class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);
template <class Ret, class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);

模板参数说明：

• fn：可调用对象。
• args...：要绑定的参数列表：值或占位符。

调用bind的一般形式

调用bind的一般形式为：

auto newCallable = bind(callable, arg_list);

解释说明：

• callable：需要包装的可调用对象。
• newCallable：生成的新的可调用对象。
• arg_list：逗号分隔的参数列表，对应给定的callable的参数。当newCallable时，newCallable会调用callable，并传给它arg_list中的参数。

arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置，比如_1为newCallable的第一个参数，_2为第二个参数，以此类推。

此外，除了用auto接收包装后的可调用对象，也可以用function类型指明返回值和形参类型后接收包装后的可调用对象。

②bind包装器绑定固定参数

无意义的绑定

下面这种绑定就是无意义的绑定：

int Plus(int a, int b)
{
	return a + b;
}
int main()
{
	//无意义的绑定
	function<int(int, int)> func = bind(Plus, placeholders::_1, placeholders::_2);
	cout << func(1, 2) << endl; //3
	return 0;
}

绑定时第一个参数传入函数指针这个可调用对象，但后续传入的要绑定的参数列表依次是placeholders::_1和placeholders::_2，表示后续调用新生成的可调用对象时，传入的第一个参数传给placeholders::_1，传入的第二个参数传给placeholders::_2。此时绑定后生成的新的可调用对象的传参方式，和原来没有绑定的可调用对象是一样的，所以说这是一个无意义的绑定。

绑定固定参数

如果想把Plus函数的第二个参数固定绑定为10，可以在绑定时将参数列表的placeholders::_2设置为10。比如：

int Plus(int a, int b)
{
	return a + b;
}
int main()
{
	//绑定固定参数
	function<int(int)> func = bind(Plus, placeholders::_1, 10);
	cout << func(2) << endl; //12
	return 0;
}

此时调用绑定后新生成的可调用对象时就只需要传入一个参数，它会将该值与10相加后的结果进行返回。

③bind包装器调整传参顺序

调整传参顺序

对于下面Sub类中的sub成员函数，sub成员函数的第一个参数是隐藏的this指针，如果想要在调用sub成员函数时不用对象进行调用，那么可以将sub成员函数的第一个参数固定绑定为一个Sub对象。比如：

class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};
int main()
{
	//绑定固定参数
	function<int(int, int)> func = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);
	cout << func(1, 2) << endl; //-1
	return 0;
}

此时调用绑定后生成的可调用对象时，就只需要传入用于相减的两个参数了，因为在调用时会固定帮我们传入一个匿名对象给this指针。

如果想要将sub成员函数用于相减的两个参数的顺序交换，那么直接在绑定时将placeholders::_1和placeholders::_2的位置交换一下就行了。比如：

class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};
int main()
{
	//调整传参顺序
	function<int(int, int)> func = bind(&Sub::sub, Sub(), placeholders::_2, placeholders::_1);
	cout << func(1, 2) << endl; //1
	return 0;
}

根本原因就是因为，后续调用新生成的可调用对象时，传入的第一个参数会传给placeholders::_1，传入的第二个参数会传给placeholders::_2，因此可以在绑定时通过控制placeholders::_n的位置，来控制第n个参数的传递位置。

④bind包装器的意义

• 将一个函数的某些参数绑定为固定的值，让我们在调用时可以不用传递某些参数。
• 可以对函数参数的顺序进行灵活调整。

---

本文到此结束，码文不易，还请多多支持！！！