C++11新特性（二）：更好用的 lambda 表达式和 function 包装器

翼蛇湖-纪宁

于 2024-03-31 22:24:28 发布

阅读量1.3k

点赞数 28

分类专栏： C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/zyb___/article/details/137183024

版权

C++ 专栏收录该内容

30 篇文章 0 订阅

订阅专栏

本文详细介绍了C++11引入的lambda表达式，包括其基本格式、参数列表、捕捉列表的使用，以及function和bind包装器的应用，展示了如何利用lambda简化代码并提高效率。

摘要由CSDN通过智能技术生成

lambda 表达式

C++11引入了lambda表达式，它是一种用于创建匿名函数的语法。lambda表达式可以被视为一个匿名函数对象，它可以在需要函数对象的地方使用。

基本格式及参数列表

它的语法格式如下：

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

[capture -list] 为捕捉列表，是一个可选项，该列表总是出现在 lambda 函数的开始位置，编译器根据 [] 来判断接下来的代码是否为lambda 函数，捕捉列表能够捕捉上下文中的变量供 lambda 函数使用。（lambda 函数的参数可以用参数列表捕捉，也可以在参数中传递）

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

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

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

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

下面是关于 lambda 的基础使用示例

	int x = 7, y = 2;
	// auto f = []mutable{cout << 1 <<endl;}; // 报错，因为一但加了 mutable，因为没参数的时候必须加 ()
	auto f = []()mutable{cout << 1 <<endl;}; 
	auto f2 = [x, y](int a, int b)->int { return x + y + a + b; };
	cout << f2(2, 3) << endl; // 14
	auto f3 = [&x, &y](){ x = 1, y = 2; }; // 无参数也无返回值, 引用捕捉, 并修改
	f3();
	cout << x << " " << y << " " << endl; // 1 2
	auto f1 = [x, y]() mutable {x = 2, y = 7; cout << x << " " << y << " " << endl;};  
	f1();// 2 7 虽然 mutable 使可以在 lambda 函数体里修改参数值, 但无法带出来 
	cout << x << " " << y << " " << endl; // 1 2
	auto f4 = [](int a, int b)mutable{a = 6, b = 18; cout << a << " " << b << " " << endl; };
	f4(9, 10); // 6 18 
	auto f6 = [](int a, int b) {a = 9, b = 29; cout << a << " " << b << " " << endl; };
	f6(9, 99); // 9 29  // 传进来的参数无论加不加 mutable, 都能修改  


// 数组排序 ///
	int array[] = { 4,1,8,5,3,7,0,9,2,6 };
	// 默认按照小于比较，排出来结果是升序
	std::sort(array, array + sizeof(array) / sizeof(array[0]), less<int>()); // less 也可以写
	std::sort(array, array + sizeof(array) / sizeof(array[0])); // 如果是升序, less 也可以不写
	for (auto e : array) cout << e << " ";
	cout << endl;
	// 使用 lambda 表达式来书写
	std::sort(array, array + sizeof(array) / sizeof(array[0]), [](int a, int b)->bool {return a < b;});
	for (auto e : array) cout << e << " ";
	cout << endl;
	// 如果需要降序，需要改变元素的比较规则
	std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());
	for (auto e : array) cout << e << " ";
	cout << endl;
	// 使用 lambda 表达式来书写
	std::sort(array, array + sizeof(array) / sizeof(array[0]), [](int a, int b)->bool {return a > b; });
	for (auto e : array) cout << e << " ";
	cout << endl;

对于 lambda 捕捉列表的说明

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

[var]：表示值传递方式捕捉变量var
[=]：表示值传递方式捕获所有父作用域中的变量(包括this)
[&var]：表示引用传递捕捉变量var
[&]：表示引用传递捕捉所有父作用域中的变量(包括this)
[this]：表示值传递方式捕捉当前的this指针

父作用域指包含lambda函数的语句块，语法上捕捉列表可由多个捕捉项组成，并以逗号分割。比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量，[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量。但捕捉列表不允许变量重复传递，否则就会导致编译错误，比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复。

lambda表达式之间不能相互赋值，即使看起来类型相同。

lambda 原来就是为了解决小型仿函数的代码冗余（为了实现仅仅一个比较功能就写一个类），如下面的的自定义类的比较功能

class Goods
{
public:
	string _name;  //名字
	double _price; // 价格
	int _evaluate; // 评价
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};
class Compare_price
{
public:
	bool operator()(const Goods& g1, const Goods g2)
	{
		return g1._price < g2._price;
	}
};

int main()
{
	vector<Goods> vG = { {"足球", 100, 10}, {"篮球", 99, 9}, {"羽毛球", 110, 11} };
	sort(vG.begin(), vG.end(), Compare_price());
	sort(vG.begin(), vG.end(), [](Goods g1, Goods g2)->bool{return g1._price > g2._price;});
	return 0;
}

function 包装器

ret = func(x); 这个语句中，func可能是函数指针，也可能是仿函数或者 lambda，如果三种都情况都有定义，那么调用的时候，就会实例化出三份，导致效率低下，那么怎么解决这个问题呢？

可以使用包装器 function 来解决

std::function 在头文件 <functional> 中
function 包装器的类模板原型如下

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

模板参数说明：

Ret：被调用函数的返回类型
Args…：被调用函数的形参

function 包装器的使用方式如下：

class Goods{
public:
	string _name;  //名字
	double _price; // 价格
	int _evaluate; // 评价
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};
class Compare_price{
public:
	bool operator()(const Goods& g1, const Goods g2){
		return g1._price < g2._price;
	}
};

int main()
{
	vector<Goods> vG = { {"足球", 100, 10}, {"篮球", 99, 9}, {"羽毛球", 110, 11} };
	function<bool(const Goods, const Goods)> func1 = [](Goods g1, Goods g2)-> bool {return g1._evaluate > g2._evaluate; };
	function<bool(const Goods, const Goods)> func2 = Compare_price();
	sort(vG.begin(), vG.end(), func);
	return 0;
}

function 也有下面的用途：

逆波兰表达式求值在力扣的逆波兰表达式求值中，这道题如果使用 if else 来判断的话，需要写好多判断，但如果用 function 包装器来写的话，代码就比较简简洁！

传统版本：写多个 if 来判断：

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        for(auto& e: tokens)
        {
            if(e == "+" || e == "-" || e == "*" || e == "/")
            {
                int right = st.top();
                st.pop();
                int left = st.top();
                st.pop();
                if(e == "+") st.push(left + right);
                else if(e == "-") st.push(left - right);
                else if(e == "*") st.push(left * right);
                else if(e == "/") st.push(left / right);
            }
            else st.push(stoi(e));
        }
        return st.top();
    }
};

使用 function 之后：

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        map<string, function<int(int, int)>> opMap = {
            {"+", [](int a, int b)->int{return a + b;}},
            {"-", [](int a, int b)->int{return a - b;}},
            {"*", [](int a, int b)->int{return a * b;}},
            {"/", [](int a, int b)->int{return a / b;}}
        };
        for(auto& e: tokens)
        {
            if(e == "+" || e == "-" || e == "*" || e == "/")
            {
                int right = st.top();
                st.pop();
                int left = st.top();
                st.pop();
                st.push(opMap[e](left, right));
            }
            else st.push(stoi(e));
        }
        return st.top();
    }
};

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中的参数。

	function<int(int, int)> func1 = bind(Plus, placeholders::_2, placeholders::_1); // bind 普通函数，并将第二个参数与第一个参数交换位置
	cout << func1(1, 9);
	// bind 成员 函数，并保持参数位置不变
	function<int(int,int)> func2 = bind(&Sub::sub, Sub()/*这里必须传一个对象*/, placeholders::_1, placeholders::_2); 
	cout << " " << func2(9, 1) << endl;

也可以绑定某一个参数

	// placeholders::_n , n 代表函数传递的第 n 个参数
	function<int(int, int)> func3 = bind(&Sub::sub, Sub()/*这里必须传一个对象*/, 20, placeholders::_1); // 20 - 90
	function<int(int, int)> func4 = bind(&Sub::sub, Sub()/*这里必须传一个对象*/, 20, placeholders::_2); // 20 - 10
	cout << func3(90, 10) << endl;
	cout << func4(90, 10) << endl;