C++11：lambda表达式

已于 2023-06-04 16:36:28 修改
阅读量1.8w 收藏 222
点赞数 57
文章标签： c++
于 2022-09-30 22:05:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhang_si_hang/article/details/127117260
版权

目录

一.lambda表达式

1.格式

2. lambda表达式各部分说明

3.举例

（1）例子1：相加函数

 （2）[ ]捕捉列表 例子2：交换函数

        仿函数比较，lambda更易懂

 4.lambda注意点

5.底层原理

二.包装器

1.可调用类型对象

2.function包装器

解决useF问题

3.包装器改装逆波兰表达式

4.bind 绑定

（1）调整可调用对象参数的个数

（2）调整可调用对象参数的顺序（用处不大）

bind总代码：

 

一.lambda表达式

lambda表达式就是定义了一个可调用的匿名函数，一般在局部。

 []{}是最简单的lambda表达式，但是该lambda表达式没有任何意义

1.格式

lambda表达式书写格式： [capture-list] (parameters) mutable -> return-type { statement
}

     [capture-list] (parameters) mutable -> return-type { statement }
     捕捉列表          参数  去const（单词意思易变的）   返回值       函数体

auto Add1 = [ ](int x, int y)->int {return (x + y); };

2. lambda表达式各部分说明

（1）[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置， 编译器根据[]来
判断接下来的代码是否为lambda函数， 捕捉列表能够捕捉上下文中的变量供lambda 函数使用。
捕捉的参数都是自带const的，想要去掉const属性可以用mutable，但是捕捉的对象(变量)仍是一份拷贝，外部的a，b无法被修改，所以mutable 很少用，意义不大，不如用 [&]引用捕捉 ( )引用传参
 
（2）(parameters)：参数列表。与 普通函数的参数列表一致，如果不需要参数传递，则可以
连同()一起省略。所传参数和捕捉参数不一样，不自带const，可以修改
 
（3）mutable： 默认情况下，lambda函数总是一个const函数，mutable可以取消其常量
性。 使用该修饰符时，参数列表不可省略(即使参数为空时，也要带上小括号)。mutable 只是让传值捕捉变量const属性去掉了，但是捕捉的a，b仍是拷贝，外部的a，b无法被修改，所以mutable 很少用，意义不大
 
（4） ->returntype：返回值类型。用 追踪返回类型形式声明函数的返回值类型，没有返回
值时此部分可省略。 返回值类型明确情况下，也可省略，由编译器对返回类型进行推 导。
 
（5） {statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获
到的变量。
 
注意：
在lambda函数定义中， 参数列表和返回值类型都是可省略部分，而捕捉列表和函数体可以为
空，但不可省略，因此C++11中 最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。

 

2d58c7b7cb2240ad983c9d50812f7fda.png

3.举例

（1）例子1：相加函数

    int a = 0, b = 200;
	// [capture-list] (parameters) mutable -> return-type { statement }
	// 捕捉列表  参数  返回值  函数体

	// 一般是局部匿名函数  也可以写到全局
	auto Add1 = [](int x, int y)->double {return (x + y) / 3.0; };
	auto Add2 = [](int x, int y)->int {return (x + y) / 3.0; };//传参写法
	auto Add3 = [a, b] {return (a + b) / 3.0; };//捕捉变量写法

	cout << Add1(a, b) << endl;
	cout << Add2(a, b) << endl;
	cout << Add3() << endl;

 （2）[ ]捕捉列表 例子2：交换函数

3,4,5,6是几种捕捉方式

1.	auto Swap1 = [](int& x, int& y){
		int tmp = x;
		x = y;
		y = tmp;
	};

	Swap1(a, b);
	cout << a << " " << b << endl;

2.	mutable 只是让传值捕捉变量const属性去掉了，但是捕捉的a，b仍是拷贝，外部的a，b无法被修改
	/*auto Swap2 = [a, b]()mutable{
		int tmp = a;
		a = b;
		b = tmp;
	};*/

	用引用的方式捕捉:
	auto Swap2 = [&a, &b]{
		int tmp = a;
		a = b;
		b = tmp;
	};

	Swap2();
	cout << a << " " << b << endl;

3.	int c =2, d=3, e=4, f=5, g=6, ret;
	传值捕捉全部对象
	auto Func1 = [=]{
		return c + d*e / f + g;
	};

	cout << Func1() << endl;

4.	传引用捕捉全部对象
	auto Func2 = [&]{
		ret = c + d*e / f + g;
	};

	Func2();
	cout << ret << endl;

5.	混着捕捉
	auto Func3 = [c, d, &ret]{
		ret = c + d;
	};

	Func3();
	cout << ret << endl;

6.	ret传引用捕捉 其他全部传值捕捉
	auto Func4 = [=, &ret]{
		ret = c + d*e / f + g;
		//c = 1;
	};

	Func4();
	cout << ret << endl;

        仿函数比较，lambda更易懂

（greater是排降序，less是排升序）

比如：仿函数 sort(v.begin(), v.end(), ComparePriceLess()); 可以写成sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){return g1._price < g2._price; });

struct Goods
{
	string _name;  // 名字
	double _price; // 价格
	int _evaluate; // 评价

	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};

struct Compare1
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._evaluate < gr._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 = { Goods( "苹果", 2.1, 5 ), { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };

	//sort(v.begin(), v.end()); 自定义类型没重载<不能用less或者greater
1.正常用仿函数写sort：
	sort(v.begin(), v.end(), Compare1());
	sort(v.begin(), v.end(), ComparePriceLess());
	sort(v.begin(), v.end(), ComparePriceGreater());
2.用lambda代替仿函数：
 （1）常规写法
	auto com1 = [](const Goods& g1, const Goods& g2){return g1._price < g2._price; };
	sort(v.begin(), v.end(), com1);
 
 （2）匿名对象写法
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
		return g1._price < g2._price; });
	
	cout << endl;

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

	cout << endl;

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

	cout << endl;

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

	cout << endl;

	return 0;
}

 4.lambda注意点

（1） 父作用域指包含lambda函数的语句块
（2） 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量
[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量
（3） 捕捉列表不允许变量重复传递，否则就会导致编译错误。
比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复
（4） 在块作用域以外的lambda函数捕捉列表必须为空。
（5） 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者
非局部变量（捕捉        全局变量会报错）都会导致编译报错。
（6） lambda对象之间不能相互赋值，即使看起来类型相同 ，因为每个lambda都会被转换成一个仿函数类型，仿函数类名称lambda+ uuid。（ lambda表达式底层被转换成仿函数）
8585f980b9c34437be876a0e2cf35386.png

但是允许使用lambda表达式拷贝构造

也可以将lambda表达式赋值给相同类型的函数指针，了解一下，一般不建议这么用，意义不大

void (*PF)();
int main()
{
	auto f1 = [] {cout << "hello world" << endl; };
	auto f2 = [] {cout << "hello world" << endl; };
	
    f1 = f2;   //错误，lambda对象之间不能相互赋值，编译失败--->提示找不到operator=()
	
	auto f3(f2); //正确，允许使用一个lambda表达式拷贝构造一个新的副本
	f3();
	// 可以将lambda表达式赋值给相同类型的函数指针，了解一下，一般不建议这么用
	PF = f2;    //上面有void (*PF)(); PF和f2都是无类型无返回值
	PF();
	return 0;
}

5.底层原理

lambda表达式底层是一个仿函数。每个lambda都会被转换成一个仿函数类型，仿函数类名称lambda+ uuid。uuid是生成的随机不同的字符串，防止冲突

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;
	Rate r1(rate);
	r1(10000, 2);
	// lamber
	auto r2 = [=](double monty, int year)->double {return monty * rate * year;};
	r2(10000, 2);
	return 0;
}

仿函数：函数对象，又称为仿函数，即可以像函数一样使用的对象，就是在类中重载了operator()运算符的类对象。

r1就是仿函数，这里调用的是重载的了operator()运算符。lambda底层则是被转换成了一个 类名称叫lambda+ uuid 的仿函数，r2(10000, 2);就是调用了此仿函数的operator()运算符

7f49be8bac424014a55f441c3c17da2f.png

 

二.包装器

1.可调用类型对象

1、函数指针
2、仿函数对象
3、lambda

ret = func(x);
// 上面func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能
是lamber表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！
为什么呢？我们继续往下看。 
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;

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

	return 0;
}
0eb4898ed2854224b97d1fd5b2c210af.png

 

通过上面的程序验证，我们会发现useF函数模板实例化了三份。

包装器可以很好的解决上面的问题，下面有“解决 useF问题”

2.function包装器

把对应的可调函数 函数指针/仿函数/lambda 包装起来使用，比如包装lambda：

std::function<int(int, int)> func5 = [](int a, int b) {return a + b; }; ——包装
cout << func5(100, 200) << endl;      ——包装以后直接使用

包装器用途：统一类型，

7c60f6c7a67e489b97c126667496ada0.png

std::function<int(int, int)> func1 = f; 

第一个int是被调用函数的返回类型，小括号俩int是被调用函数的形参类型，f是要包的那个函数。

template <class Ret, class... Args>

class function<Ret(Args...)>;
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参
1、函数指针 （传函数名）
2、仿函数对象（传对象）
3、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()
{
	std::function<int(int, int)> func1 = f;
	cout << func1(1, 2) << endl;

	std::function<int(int, int)> func2 = Functor();
	cout << func2(10, 20) << endl;
	
     静态成员函数包装可以加&也可以不加（建议都加&）
	std::function<int(int, int)> func3 = &Plus::plusi;
	cout << func3(100, 200) << endl;

	 规定：非静态成员函数包装必须加&，因为有this指针，所以参数多传一个域
	std::function<double(Plus, double, double)> func4 = &Plus::plusd;
	cout << func4(Plus(), 100.11, 200.11) << endl;//Plus()是匿名对象，有对象才能调函数

	std::function<int(int, int)> func5 = [](int a, int b) {return a + b; };
	cout << func5(100, 200) << endl;

	return 0;
}

bba9e2c93a4843b08a1b817f28a7a54b.png

解决useF问题

解决：包装器，把函数/仿函数/lambda表达式 包装成一个类型，只实例化一份


#include <functional>

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()
{
	// 函数名
	std::function<double(double)> func1 = f;
	cout << useF(func1, 11.11) << endl;

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

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

	return 0;
}

9036c84c19ba4ac4b608ba4bdd1940fd.png

3.包装器改装逆波兰表达式

150. 逆波兰表达式求值

e78b69251dad4a4d91792188bccd6cb1.png

 例如：

 ["4","13","5","/","+"] ，把4,13,5入栈，取到“/”后，13/5=2,2入栈，栈里有：4,2；取到 “+” 后，4+2=6，结果为6

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

 

4.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);

fn是可调用对象，Args&&... args是参数包

占位对象：_1是显示传的第一个参数，_2是显示传的第二个参数， _1 _2 _3... 表示你要自己传的那些参数，_1表示第一个参数传给_1（_1，_2都属于一个叫placeholders的域）

（可调用类型对象：1、函数指针 2、仿函数对象 3、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:
	Plus(int x = 2)
		:_x(x)
	{}

	int plusi(int a, int b)
	{
		return (a + b)*_x;
	}
private:
	int _x;
};

int main()
    std::function<int(int, int)> func1 = f;
	cout << func1(1, 2) << endl;

	std::function<int(int, int)> func2 = Functor();
	cout << func2(10, 20) << endl;
但是非静态的成员函数因为有this，需要传3个参数 
    // 3个参数
	std::function<int(Plus, int, int)> func3 = &Plus::plusi;
	cout << func3(Plus(), 100, 200) << endl;

就导致定义map时,map的second类型是两个参数的包装器，则这3个参数的传不进去，只能通过bind解决：

f3eaf10b1af64c6483853e334ffe9c08.png

	map<string, std::function<int(int, int)>> opFuncMap =
	{
		{ "普通函数指针", f },
		{ "函数对象", Functor() },
		{ "成员函数指针", std::bind(&Plus::plusi, Plus(10), placeholders::_1, placeholders::_2) }
	};

（1）调整可调用对象参数的个数

改成传2个参数的：

2个参数 这里相当于绑定了第一个参数10；1个参数 这里相当于绑定了第一个参数为10，第二个参数为30；

// 2个参数
	std::function<int(int, int)> func4 = std::bind(&Plus::plusi, Plus(10), placeholders::_1, placeholders::_2);
	cout << func4(10,20) << endl;

如果用bind改成传一个参数的：
	// 1个参数
	std::function<int(int)> func5 = std::bind(&Plus::plusi, Plus(10),
		30, placeholders::_1);

	cout << func5(200) << endl;

（2）调整可调用对象参数的顺序（用处不大）

此时66传给_1，77传给_2，f函数中a接收_2的77，b接收_2的66


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

int main()
{
未调整：
    std::function<int(int, int)> func1 = f;
	cout << func1(66, 77) << endl;
调整顺序：	
// 调整顺序 -- 用处不大
	std::function<int(int, int)> func6 = std::bind(f, placeholders::_2,
                                                     placeholders::_1);
	cout << func6(66, 77) << endl;
}

bind总代码：

占位对象：_1是显示传的第一个参数，_2是显示传的第二个参数， _1 _2 _3... 表示你要自己传的那些参数，_1表示第一个参数传给_1 
int f(int a, int b)
{
	return a - b;
}

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


class Plus
{
public:
	Plus(int x = 2)
		:_x(x)
	{}

	int plusi(int a, int b)
	{
		return (a + b)*_x;
	}
private:
	int _x;
};

int main()
{
	std::function<int(int, int)> func1 = f;
	cout << func1(1, 2) << endl;

	std::function<int(int, int)> func2 = Functor();
	cout << func2(10, 20) << endl;

	// 3个参数
	std::function<int(Plus, int, int)> func3 = &Plus::plusi;
	cout << func3(Plus(), 100, 200) << endl;

	// 调整可调用对象的参数个数和顺序
	// _1 _2 _3... 表示你要自己传的那些参数，_1表示第一个参数传给_1
	// 调整个数
	// 2个参数
	std::function<int(int, int)> func4 = std::bind(&Plus::plusi, Plus(10),
placeholders::_1, placeholders::_2);

	// 1个参数
	std::function<int(int)> func5 = std::bind(&Plus::plusi, Plus(10),
		10, placeholders::_1);

	cout << func5(200) << endl;

	// 调整顺序 -- 用处不大
	std::function<int(int, int)> func6 = std::bind(f, placeholders::_2,
placeholders::_1);
	cout << func1(66, 77) << endl;
	cout << func6(66, 77) << endl;

	map<string, std::function<int(int, int)>> opFuncMap =
	{
		{ "普通函数指针", f },
		{ "函数对象", Functor() },
		{ "成员函数指针", std::bind(&Plus::plusi, Plus(10), placeholders::_1, placeholders::_2) }
	};

	cout << opFuncMap["普通函数指针"](1, 2) << endl;
	cout << opFuncMap["函数对象"](1, 2) << endl;
	cout << opFuncMap["成员函数指针"](1, 2) << endl;


	return 0;
}

 

 

 

 

 

 

 

sponge'
关注
  • 57
    点赞
  • 踩
  • 222
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
C++ 中lambda表达式的编译器实现原理
08-31
C++ 11加入了一个非常重要的特性——Lambda表达式。这篇文章主要介绍了C++ 中lambda表达式的编译器实现原理,需要的朋友可以参考下
C++中的Lambda表达式详解
09-04
主要介绍了C++中的Lambda表达式详解,本文讲解了基本语法、Lambda的使用等内容,需要的朋友可以参考下
C++11新特性：Lambda表达式.pdf
10-20
C++11新特性：Lambda表达式.pdf
C++中的lambda表达式详解
最新发布
热土程序园，利他愉己~
04-26 968
1.lambda 表达式（也称为 lambda 函数） lambda 表达式是C++11中引入的一种方便创建匿名函数对象的方式。它们可以捕获其所在作用域中的变量，并在需要时调用它们。 Lambda 表达式提供了一种简洁、方便的方式来定义小型的、可重用的函数对象，而无需显式地定义一个类并重载其调用运算符。 它们常用于简短的回调、排序准则、以及任何需要简单函数对象的场合。
C++ lambda表达式详解
weijianjain的博客
12-05 1365
Lambda 表达式
Lambda表达式最全解析
m0_51212267的博客
04-03 3396
目录 一、Lambda表达式简介 什么是Lambda？ 为什么使用Lambda Lambda对接口的要求 @FunctionalInterface 二、Lambda的基础语法 1.语法 2.创建多个接口 3.创建测试类 三、语法精简 1.参数类型精简 2.参数小括号精简 3.方法大括号精简 4.大括号精简补充 5.多参数，有返回值 精简 四、Lambda语法进阶 1.方法引用(普通方法与静态方法) 2.方法引用(构造方法) 一、Lambda表达式简介 什么是L
【C++】C++11——lambda表达式
weixin_60478154的博客
03-21 3767
C++11——Lambda表达式
C++ 中的Lambda表达式
Gefangenes的博客
06-24 2540
在本质上，闭包是将函数内部和函数外部连接起来的桥梁。
c++ 之Lambda表达式
d0203的博客
01-24 980
Lambda 表达式是 C++11 引入的一种匿名函数的方式，它允许你在需要函数的地方内联地定义函数，而无需单独命名函数。在某些方面有相似之处，如它们都可以被编译器优化以减少调用开销，但它们在设计和用途上有明显的不同。因此，它可以修改 x 和 y 的原始值。以上就是一个捕获列表为空，的一个Lambda表达式的简单应用。函数的核心优势在于它们的匿名性和对外部变量的捕获能力，而。我们先回忆一下回调函数的写法，下面要实现找最大值的功能。是在 Lambda 定义时的值的拷贝。是在 Lambda 定义时的值的拷贝。
【C++11】—— lambda表达式
M的博客
01-15 884
lambda表达式的基本使用
C++11新特性--Lambda表达式
没有最好，只有更好！
08-10 1172
C++11新特性–Lambda表达式 Lambda表达式 功能：定义并创建匿名函数对象，以简化编程工作。 Lambda语法形式 [函数对象参数] (操作符重载函数参数) mutable或exception声明-&gt;返回值类型 {函数体} Lambda语法分析 函数对象参数：表示Lambda开始，必须存在，不能省略。它传递给编译器自动生成函数对象类的构造函数。它只能使用定义在Lambd...
C++ 11 lambda 表达式
05-10
Microsoft Visual Studio.Net(VS2010)编写的lambda表达式语法控制台程序。
C++ 中的 Lambda 表达式
10-29
C++11中才支持lambda表达式，使用lambda，可以直接代替回调函数。不需要再去写一个函数，直接在调用的地方写代码。类似于javascript中的回调。
C++11 lambda表达式
12-22
C++11中的lambda表达式是一种强大的特性，它允许程序员在代码中定义匿名函数，这些函数可以在需要的地方直接使用，而无需预先声明。这极大地方便了代码的编写，特别是对于那些只用一次的函数，同时也增加了代码的...
C++ 中的Lambda表达式写法
08-31
Lambda表达式引入了C++11标准，极大地提升了代码的灵活性和可读性，特别是在处理算法、回调函数以及异步编程时。 ### 一、Lambda表达式的语法 Lambda表达式的通用形式如下： ```cpp [capture_list] (parameters) ...
一文读懂c++11 Lambda表达式
01-19
C++11新增了很多特性，Lambda表达式（Lambda expression）就是其中之一，很多语言都提供了 Lambda 表达式，如 Python，Java ，C#等。本质上， Lambda 表达式是一个可调用的代码单元[1]^{[1]}[1]。实际上是一个闭包...
C++ lambda表达式
qq_45604814的博客
09-05 6200
Lambda表达式是C++11标准引入的一种特性，它提供了一种方便的方式来定义匿名函数。Lambda表达式是一种能够捕捉外部变量并使用它们的函数对象。由捕获列表、参数列表、返回类型和函数体组成；其中，参数列表和返回类型可以忽略，但不可以忽略捕获列表和函数体。[捕获列表](参数列表) -> 返回类型 {函数体}例如：auto f = []{ return 1 + 2;或者 auto f = [](int x, int y)->int{ return x + y;（在后面章节会详细介绍使用规则.）
C++ Lambda表达式详解
酷小川的博客
06-17 5844
Lambda表达式概述：用于创建匿名的函数对象，用于简化编程工作。 语法形式如下: [函数对象参数] （操作符重载函数参数）mutable或exception声明 ->返回类型{函数体} 1.函数对象参数 标示一个Lambda表达式的开始，必须存在，不能省略。函数参数对象只能使用那些定义Lambda 为止时Lambda所在作用范围内可见的局部变量（包含Lambda所在类的this） (1)[]:没有任何函数参数对象 (2)[=]:以值传递方式捕获Lambda所在范围内的所有局...
c++的lambda表达式捕获this_现代 C++：Lambda 表达式
05-25
Lambda表达式是C++11引入的一种函数对象，可以在需要函数对象的地方使用，比如作为函数参数、返回值等。Lambda表达式的语法形式如下： ``` [capture list](parameters) mutable exception -> return type { // function body } ``` 其中，`capture list` 表示捕获列表，用于捕获外部变量。`parameters` 表示函数参数列表，`mutable` 用于表示是否可以修改值传递的变量，`exception` 是异常列表，`return type` 表示返回类型，`function body` 则是函数体。 在Lambda表达式中，可以通过 `[this]` 捕获当前对象的指针，即 `this` 指针，可以方便地访问当前对象的成员变量和成员函数。例如： ``` class MyClass { public: void foo() { int x = 1; auto lambda = [this, x]() mutable { this->m_member_var += x; this->m_member_function(); x++; }; lambda(); } private: int m_member_var; void m_member_function(); }; ``` 在上面的例子中，Lambda表达式通过 `[this, x]` 捕获了当前对象的指针和 `foo()` 函数中定义的变量 `x`。在 Lambda 表达式中可以通过 `this->m_member_var` 和 `this->m_member_function()` 访问当前对象的成员变量和成员函数。由于 `x` 是值传递的，所以在 Lambda 表达式中需要使用 `mutable` 关键字使其可修改，可以通过 `x++` 修改变量的值。最后调用 `lambda()` 执行 Lambda 表达式。 需要注意的是，Lambda表达式捕获 `this` 指针时，需要保证当前对象是有效的，即不能在已经销毁的对象中访问成员变量和成员函数。
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值