【C++11(下)】—— 我与C++的不解之缘(三十二)

前言

随着 C++11 的引入,现代 C++ 语言在语法层面上变得更加灵活、简洁。其中最受欢迎的新特性之一就是 lambda 表达式(Lambda Expression) ,它让我们可以在函数内部直接定义匿名函数 。配合 std::function 包装器 使用,可以大大提高代码的表达力与可维护性。

一、lambda 表达式基础语法

lambda表达式本质上就是一个匿名函数对象,与普通函数不同的是,它可以定义在函数内部;

一般情况下我们是使用auto或者模版参数定义的对象去接受lambda对象。

lambda表达式本质上是一个可调用对象(函数对象),其语法格式如下:

cpp 复制代码
[capture](parameter_list) -> return_type {
    function_body
};

各部分含义如下:

部分 含义
[] 捕捉列表(capture list)
() 参数列表(与函数类似)
-> return_type 返回类型(可省略,自动推导)
{} 函数体
cpp 复制代码
int main()
{
    auto add = [](int a, int b) -> int {
    	return a + b;
	};
	std::cout << add(2, 3); // 输出:5
}

也可以省略 -> int,由编译器自动推导:

cpp 复制代码
int main()
{
    auto add = [](int a, int b){
    	return a + b;
	};
	std::cout << add(2, 3); // 输出:5
}

这里呢,参数列表,如果不需要传参,可以省略,()也可以省略;返回值类型可以省略,让编译器自行推导。

而参数列表和函数体,就算为空,参数列表的[]和函数体的{}也不能省略。

捕获列表

捕获列表决定了 Lambda 表达式如何访问其所在作用域的变量

捕获方式 语法 说明
值捕捉 [x] 捕获变量 x 的当前值(拷贝)
引用捕捉 [&x] 捕获变量 x 的引用
隐式值捕捉 [=] lambda使用了哪些变量,编译器就会对哪些变量进行值捕捉
隐式引用捕捉 [&] lambda使用了哪些变量,编译器就会对哪些变量进行引用捕捉
混合捕捉 [=, &y] 除 y 外的所有变量为值捕获,y 为引用捕获
混合捕捉 [&, x] x外的所有变量为引用捕捉,x为值捕捉
cpp 复制代码
int main()
{
    int x = 10, y = 20;

	auto f1 = [=]() { return x + y; };   // 值捕获
	auto f2 = [&]() { x += y; };         // 引用捕获,修改外部变量
	auto f3 = [x, &y]() { y += x; };     // 混合捕获
    return 0;
}

这里lambda表达式如果在函数局部域中,它可以捕捉lambda位置之前定义的变量,但是不能捕捉静态局部变量和全局变量(静态局部变量和全局变量也不需要捕捉,lambda表达式中也可以直接使用)。

如果lambda定义在全局,那捕捉列表必须为空

值捕获的变量在 Lambda 中是"只读"的,不能修改,除非加上 mutable

mutable 关键字

默认情况下,lambda捕捉列表的值是被const修饰的,值捕获的变量不能在 Lambda 中被修改 。要想修改值捕获的副本,可以使用 mutable

cpp 复制代码
int main()
{
    int a = 5;
	auto f = [a]() mutable {
    	a += 10; // 修改的是a的拷贝,不影响外部 a
    	cout << a << endl;
	};
	f();            //  15
	std::cout << a << endl; //  5
    return 0;
}

lambda 的实际应用场景

与 STL 算法结合

cpp 复制代码
std::vector<int> vec = {1, 2, 3, 4, 5};
std::for_each(vec.begin(), vec.end(), [](int x) {
    std::cout << x << " ";
});

条件查找

cpp 复制代码
auto it = std::find_if(vec.begin(), vec.end(), [](int x) {
    return x > 3;
});
if (it != vec.end()) std::cout << *it; // 输出 4

排序自定义规则

cpp 复制代码
std::sort(vec.begin(), vec.end(), [](int a, int b) {
    return a > b; // 降序
});

lambda的原理

lambda的原理和范围for非常相似,编译之后从汇编的角度来看,我们就要发现根本就没有lambda范围for

范围for的底层是迭代器,而lambda的底层是仿函数对象,简单来说我们写了一个lambda,编译器就会生成一对应的仿函数。

而仿函数的类名是编译器按照一定的规则生产的,保证不同的lambda生成的仿函数不同。

  • lambda的参数/返回值/函数体就是仿函数operator()的参数/返回类型/函数体
  • lambda捕捉列表的本质是生成的仿函数的成员变量。

简单来说就是捕捉列表的量都是lambda类构造函数的实参;

这样就很好解释值捕捉引用捕捉了:

  • 值捕捉:lambda生成的仿函数的成员就是对捕捉变量的值拷贝。
  • 引用捕捉:lambda生成的仿函数的成员就是对捕捉变量的引用。

而也支持隐式捕捉,这个就是编译器看需要用哪些对象,就传哪些对象(用多少捕捉多少)。

二、包装器

function

function是一个类模板,也是一个包装器。std::function的实例化对象可以包装存储其它可以调用的对象:包括函数指针仿函数lambdabind表达式;

其中存储的对象被称为std::function的目标;如果std::function不含目标,那它为空(调用空目标导致抛出std::bad_function_call异常。

cpp 复制代码
template <class T>
class function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;

以上是 function 的原型,他被定义头⽂件中

cpp 复制代码
#include <functional>
int main()
{
	function<int(int, int)> func;
	func = [](int a, int b) { return a + b; };
	cout << func(3, 4) << endl; // 输出 7
    return 0;
}

function 的优势在于统一函数接口、做函数回调或作为参数传递。

函数指针、仿函数、lambda这些可以调用的对象的类型各不相同,std::function的优势就在于统一类型;

只要它们返回值,参数都相同,function就能对它们进行包装;这样在很多的地方就可以声明这些可调用对象的类型;

cpp 复制代码
int fun(int a, int b)
{
	return a + b;
}
struct Fun
{
public:
	int operator() (int a, int b)
	{
		return a + b;
	}
};
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 = fun;//函数指针
	function<int(int, int)> f2 = Fun();//仿函数
	function<int(int, int)> f3 = [](int a, int b) {return a + b; };//lambda
	cout << f1(1, 1) << endl;
	cout << f2(1, 1) << endl;
	cout << f3(1, 1) << endl;

	//包装静态成员,需要指定类域并且使用&
	function<int(int, int)> f4 = &Plus::plusi;
	cout << f4(1, 1) << endl;

	//包装非静态成员函数时
	//这里还有一个隐藏的this指针,所以使用function包装后需要传对象或者对象的指针过去才能进行调用
	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, 1.1) << 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;
}

这里再来看一道可以使用function包装优化的题目

150. 逆波兰表达式求值 - 力扣(LeetCode)

cpp 复制代码
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();
                switch(e[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(e));
            }
        }
        return st.top();
    }
};

这道题,向上述这样写,特别难受好吧,我们可以使用function进行优化:

我们知道+-*/运算它返回值和参数类型都是相同的,那我们不妨将其包装起来;

然后使用map存储运算符和对应的函数/调用对象

这样直接使用map[]就可以访问到要调用的函数/对象。

cpp 复制代码
class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        map<string,function<int(int,int)>> mp = {
            {"+",[](int x,int y){return x+y;}},
            {"-",[](int x,int y){return x-y;}},
            {"*",[](int x,int y){return x*y;}},
            {"/",[](int x,int y){return x/y;}}
        };
        for(auto& e:tokens)
        {
            if(mp.count(e))//mp中存在就代表是操作符
            {
                int right = st.top();
                st.pop();
                int left = st.top();
                st.pop();
                st.push(mp[e](left,right));
            }
            else
                st.push(stoi(e));
        }
        return st.top();
    }
};

这样我们代码看起来简洁了好多,用起来也很方便;

如果再多几个运算符,我们只需要在mp再新增即可。

从这个角度来看:lambda算是统一了那些可调用对象的类型,这样对于可调用对象(函数指针仿函数lambda),只要参数和返回值相同,那我们就可以使用function包装起来,方便调用。

bind 与占位符

cpp 复制代码
simple(1)
template <class Fn, class... Args>
	bind (Fn&& fn, Args&&... args);
with return type (2)
template <class Ret, class Fn, class... Args>
	bind (Fn&& fn, Args&&... args);
  • bind是一个函数模版,它也是一个可调用对象的包装器;简单来说它就是一个函数适配器,可以对接受的Fn可调用对象进行处理后返回一个可调用对象。
  • bind可以用来调整参数个数和参数的顺序。
  • bind也在这个头文件中。
cpp 复制代码
int Fun(int a, int b)
{
	return (a - b) * 10;
}
int Func(int a, int b, int c)
{
	return (a - b - c) * 10;
}
int main()
{
	//这里_1始终指接受第一个实参
	//_2指接受第二个实参
	auto fun1 = bind(Fun, _1, _2);
	cout << fun1(10, 5) << endl;//fun1(10,5) -> Fun(10,5)
	auto Fun2 = bind(Fun, _2, _1);
	cout << Fun2(10, 5) << endl;//fun2(10,5) -> Fun(5,10)
	auto fun3 = bind(Fun, 100, _1);
	cout << fun3(5) << endl;//fun3(5) -> Fun(100,5)
	auto fun4 = bind(Fun, _1, 100);
	cout << fun4(5) << endl;//fun4(5) -> Fun(5,100)
	auto fun5 = bind(Func, 100, _1, _2);
	cout << fun5(5, 1) << endl;//fun5(5,1) -> Func(100,5,1)
	auto fun6 = bind(Func, _1, 100, _2);
	cout << fun6(5, 1) << endl;//fun6(5,1) -> Func(5,100,1)
	auto fun7 = bind(Func, _1, _2, 100);
	cout << fun7(5, 1) << endl;//fun7(5,1) -> Func(5,1,100);
	return 0;
}

调用bindauto newCallable = bind(callable, arg_list)(这里newCallable本身就是一个可调用对象,arg_list是参数列表,对应给定的callable的参数(也是可调用对象)

这样我们调用newCallablenewCallable就会调用callable,并传给它arg_list中的参数。

当我们使用function去包装类的非静态成员函数时,我们在调用时总是需要传该类型的对象或者该类型对象的指针,来完成调用;

这样的设计好难看,我每一次调用还要创建一个该类型的对象,那我还不如直接去调用呢

cpp 复制代码
	function<double(Plus&&, double, double)> f1 = &Plus::plusd;
	Plus pd;
	cout << f1(move(pd), 1.1, 1.1) << endl;
	cout << f1(Plus(), 1.1, 1.1) << endl;

bind这个绑定,我们可以同来绑定一些固定的参数;

就比如这里需要传递该类类型的对象或者该类型对象的指针,我们使用bind绑定,直接锁死这个参数,那这样在调用时就不用显示传递了。

cpp 复制代码
	function<double(double, double)> f2 = bind(&Plus::plusd, Plus(), _1, _2);
	cout << f2(1.1, 1.1) << endl;

到这里本篇文章内容就结束了
感谢各位的支持

我的博客即将同步至腾讯云开发者社区,邀请大家一同入驻:https://cloud.tencent.com/developer/support-plan?invite_code=2oul0hvapjsws

相关推荐
DBWYX43 分钟前
c++项目 网络聊天服务器 实现;QPS测试
c++
小萌新上大分1 小时前
SpringCloudGateWay
java·开发语言·后端·springcloud·springgateway·cloudalibaba·gateway网关
XYY3692 小时前
前缀和 一维差分和二维差分 差分&差分矩阵
数据结构·c++·算法·前缀和·差分
PacosonSWJTU2 小时前
python基础-13-处理excel电子表格
开发语言·python·excel
froginwe112 小时前
Perl 条件语句
开发语言
longlong int2 小时前
【每日算法】Day 16-1:跳表(Skip List)——Redis有序集合的核心实现原理(C++手写实现)
数据库·c++·redis·算法·缓存
24白菜头2 小时前
C和C++(list)的链表初步
c语言·数据结构·c++·笔记·算法·链表
啥都鼓捣的小yao3 小时前
利用C++编写操作OpenCV常用操作
开发语言·c++·opencv
灼华十一3 小时前
Golang系列 - 内存对齐
开发语言·后端·golang
程序媛学姐3 小时前
SpringRabbitMQ消息模型:交换机类型与绑定关系
java·开发语言·spring