【C++11新特性】lambda表达式

已于 2022-12-07 23:08:42 修改
阅读量1.7k 收藏
点赞数 1
分类专栏： 深入理解C++ 文章标签： c++ lambda
于 2022-02-03 16:14:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42815188/article/details/122770136
版权

文章目录

1.lambda表达式的格式

lambda 表达式也是一种可调用对象，它定义了一个匿名函数，并且可以捕获一定范围内的变量。lambda 表达式的语法形式可简单归纳如下：

[捕获列表](参数列表)->返回值类型{函数体};

在 C++11 中，lambda 表达式的返回值是通过 返回类型后置 语法来定义的。其实很多时候，lambda 表达式的返回值是非常明显的，因此，C++11 中允许省略 lambda 表达式的返回值定义，这样编译器就会根据 return 语句自动推导出返回值类型，如下所示：

[捕获列表](参数列表){函数体};

注意：编译器并不是总能推断出返回值类型，如果编译器推断不出来，它就会报错，这时我们需要显式给出具体的返回值类型。

lambda 表达式在没有参数的时候，参数列表是可以省略的，甚至 () 也能省略，因此像下面的写法都是正确的：

[捕获列表](){函数体};

[捕获列表]{函数体};

lambda 表达式的参数可以有默认值，函数体末尾的分号 ; 不能省略。

与普通函数不同的是，lambda 表达式可以在函数内部定义。

与普通函数相同的是，lambda 表达式通过函数调用运算符 () 进行调用。

2.lambda表达式的捕获列表

lambda 表达式的捕获列表精细地控制了 lambda 表达式能够访问的外部变量以及如何访问这些变量。

  • [] 不捕获任何变量，但不包含静态局部变量。也就是说，lambda 表达式可以直接使用静态局部变量，即静态局部变量是不需要捕获的。

  • [&] 捕获外部作用域中所有变量，并作为引用在函数体中使用（按引用捕获）。

  • [=] 捕获外部作用域中所有变量，并作为副本在函数体中使用（按值捕获）。需要注意的是，默认状态下 lambda 表达式无法修改通过复制方式捕获的外部变量。如果希望修改这些变量的话，我们需要使用引用方式进行捕获。

  • [this] 捕获当前类中的 this 指针，让 lambda 表达式拥有和当前类成员函数同样的访问权限。如果已经使用了 & 或者 =，就默认添加此选项。捕获 this 的目的是可以在 lamda 表达式中使用当前类的成员函数和成员变量。

  • [变量名, 变量名] 按值捕获变量名所代表的变量，同时不捕获其他变量。

  • [&变量名, &变量名] 按引用捕获变量名所代表的变量，同时不捕获其他变量。

  • [=, &变量名, &变量名] 按值捕获外部作用域中所有变量，但按引用捕获变量名所代表的变量。这里 = 必须写在开头位置，因为捕获列表的第一个位置是默认捕获方式（隐式捕获方式），后续其它的都是显式捕获方式。

  • [&, 变量名, 变量名] 按引用捕获外部作用域中所有变量，但按值捕获变量名所代表的变量。这里 & 必须写在开头位置。

#include <iostream>
using namespace std;

int main()
{
	int a = 10, b = 20;
	auto f1 = [] { return a; };               // 错误，没有捕获外部变量
	auto f2 = [&] { return a++; };            // 正确，按引用捕获所有外部变量，并对a执行自加运算
	auto f3 = [=] { return a; };              // 正确，按值捕获所有外部变量，并返回a
	auto f4 = [=] { return a++; };            // 错误，a是以复制方式捕获的，无法修改
	auto f5 = [a] { return a + b; };          // 错误，没有捕获变量b
	auto f6 = [a, &b] { return a + (b++); };  // 正确，按值捕获a，按引用捕获b，并对b做自加运算
	auto f7 = [=, &b] { return a + (b++); };  // 正确，按值捕获所有外部变量，按引用捕获b，并对b做自加运算

	return 0;
}

#include <iostream>
using namespace std;

class A
{
public:
    int m_i = 10;
    void func(int x, int y)
    {
        auto f1 = [] { return m_i; };                    // 错误，没有捕获外部变量
        auto f2 = [=] { return m_i + x + y; };           // 正确，捕获所有外部变量
        auto f3 = [&] { return m_i + x + y; };           // 正确，捕获所有外部变量
        auto f4 = [this] { return m_i; };                // 正确，捕获this指针
        auto f5 = [this] { return m_i + x + y; };        // 错误，没有捕获x、y
        auto f6 = [this, x, y] { return m_i + x + y; };  // 正确，捕获this指针、x、y
        auto f7 = [this] { return m_i++; };              // 正确，捕获this指针，并修改成员的值
    }
};

int main()
{
    A a;
    a.func(20, 30);

	return 0;
}

3.指定lambda表达式为mutable

如果希望去修改按值捕获的外部变量，那么就需要显式指明 lambda 表达式为 mutable。

需要注意的一点是，被 mutable 修饰的 lambda 表达式就算没有参数也要写明参数列表。

#include <iostream>
using namespace std;

int main()
{
	int a = 10;
	auto f1 = [=] { return a++; };             // 错误，按值捕获的外部变量无法修改
	auto f2 = [=]() mutable { return a++; };   // 正确，mutable

	return 0;
}

4.lambda表达式延迟调用容易出错

一个容易出错的细节是 lambda 表达式的延迟调用，在下面代码中，lambda 表达式按值捕获了所有外部变量。在捕获的一瞬间，a 的值就已经被复制到 f 中了。之后 a 被修改，但此时 f 中存储的 a 仍然还是捕获时的值，所以最终输出结果是 10 10 10。因此，如果希望 lambda 表达式在调用时能够即时访问外部变量，我们应当使用引用方式捕获。

#include <iostream>
using namespace std;

int main()
{
	int a = 10;
	auto f = [=] { return a; };      // 按值捕获外部变量
	a += 5;                          // a被修改了
	std::cout << f() << std::endl;   // 输出10

	return 0;
}

5.lambda表达式的类型

每个 lambda 表达式都会触发编译器生成一个独一无二的类类型。

lambda 表达式的类型在 C++11 中被称为“闭包类型(Closure Type)”，它是一种特殊的、匿名的类类型，我们可以认为它是一个带有 operator() 的类，即仿函数。

lambda 表达式可以认为是一个带有 operator() 的类类型对象，即函数对象。因此，我们可以使用 std::function 和 std::bind 来存储和操作 lambda 表达式：

#include <iostream>
#include <functional>
using namespace std;

int main()
{
	std::function<int(int)> fun = [](int tv) -> int { return tv; };
	cout << fun(15) << endl; // 输出15

	return 0;
}

#include <iostream>
#include <functional>
using namespace std;

int main()
{
    std::function<int(int)> fun = std::bind([](int tv) { return tv; }, 16);
    cout << fun(5) << endl; // 输出16

	return 0;
}

6.没有捕获任何变量的lambda表达式可以被转换成一个普通的函数指针

#include <iostream>
using namespace std;

int main()
{
    using funcPointer = int(*)(int); // 通过using指定别名
    funcPointer fp = [](int tv) { return tv; };
    cout << fp(17) << endl; // 输出17

	return 0;
}

lambda 表达式可以说是就地定义仿函数闭包的“语法糖”。它的捕获列表捕获住的任何外部变量，最终均会变为闭包类型的成员变量。

  • 捕获变量的 lambda 表达式不能转换为函数指针，因为一个使用了成员变量的类的 operator()，如果能直接被转换为普通的函数指针，那么 lambda 表达式本身的 this 指针就丢失掉了。

  • 而没有捕获任何外部变量的 lambda 表达式则不存在这个问题，因此，没有捕获变量的 lambda 表达式可以直接转换为函数指针。

这里也可以很自然地解释为何无法修改按值捕获的外部变量。因为按照 C++ 标准，lambda 表达式的 operator() 默认是 const 的。一个 const 成员函数是无法修改成员变量的值的。而 mutable 的作用，就在于取消 operator() 的 const。

7.声明式的编程风格、简洁的代码

就地定义匿名函数，不再需要定义函数对象，大大简化了标准库算法的调用。

7.1 在for_each()中使用lambda表达式

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

void fun(int val)
{
    cout << val << endl;
}

int main()
{
    vector<int> myvec = { 10, 20, 30, 40, 50 };
    
    for_each(myvec.begin(), myvec.end(), fun);

	return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

class A
{
public:
    A() { cout << "构造函数" << endl; }

    A(const A&) { cout << "拷贝构造函数" << endl; }

    ~A() { cout << "析构函数" << endl; }

    void operator()(int val)
    {
        cout << val << endl;
    }
};

int main()
{
    vector<int> myvec = { 10, 20, 30, 40, 50 };

    for_each(myvec.begin(), myvec.end(), A());

	return 0;
}

输出结果如下：

在这里插入图片描述

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main()
{
    vector<int> myvec = { 10, 20, 30, 40, 50 };
    
    for_each(myvec.begin(), myvec.end(), [](int val) {
        cout << val << endl;
    });

	return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main()
{
    vector<int> myvec = { 10, 20, 30, 40, 50 };

    int sum = 0;
    for_each(myvec.begin(), myvec.end(), [&sum](int val) {
        sum += val;
        cout << val << endl;
    });
    cout << "sum = " << sum << endl;

	return 0;
}

7.2 在find_if()中使用lambda表达式

find_if() 是在输入迭代器所定义的范围内查找单个对象的算法，它可以在前两个参数指定的范围内查找可以使第三个参数指定的谓词返回 true 的第一个对象。谓词不能修改传给它的对象。

find_if() 会返回一个指向被找到对象的迭代器，如果没有找到对象，会返回这个序列的结束迭代器。

在下面代码中，使用 find_if() 来查找 myvec 中第一个大于 x 的元素：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main()
{
    vector<int> myvec = { 10, 20, 30, 40, 50 };

    int x = 32;

    auto iter = find_if(myvec.begin(), myvec.end(), [x](int val) { return val > x; });

    if (iter == myvec.end())
    {
        cout << "没找到" << endl;
    }
    else
    {
        cout << "第一个大于x的元素为：" << *iter << endl;
    }

	return 0;
}
早睡身体好呀
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
lambda表达式 mutable 仿函数
qq_52088561的博客
03-23 186
lambda表达式 很像仿函数 类似于函数里面的函数 里面的变量不能改变，都是加了const的，加了mutable的变量，后面即使加了const也是可以改变的 里面的变量是重新拷贝出来的和外面的变量不一样 全局变量不需要捕获 [] 不捕获变量 [=]全部捕获按照值捕获 [&]以引用的方式捕获，他的变量是可以改变的，因为以你引用的底层就是指针 [=,&a]a是引用捕获， uto x0=[]()->int {return g_max;} 函数中this指针可以捕获，但是不可以捕获th
【例14.5】使用lambda表达式修改类成员变量（1、在成员方法中，用lambda表达式修改测试类的成员变量，再实现测试接口中的抽象方法；2、在主方法中，创建本类对象，调用成员方法）
qq_43118674的博客
05-28 242
【例14.5】使用lambda表达式修改类成员变量（1、在成员方法中，用lambda表达式修改测试类的成员变量，再实现测试接口中的抽象方法；2、在主方法中，创建本类对象，调用成员方法）
Lambda表达式
weixin_53351797的博客
05-22 147
Lambda表达式的基本构成： [函数对象参数](操作符重载函数参数)mutable ->返回值{函数体}； 第一个 [ ]参数: Lambda的开始，这部分必须存在，不能省略 空。没有使用对象参数 =。值传递方式，相当于编译器自动为我们按值传递了所有局部变量（lambda所在作用范围） &。引用传递，相当于编译器自动为我们按引用传递了所有局部变量 this。函数体内可以使用Lambda所在类中的成员变量。 a。将a按值进行传递 &a。将a按引用进行传递 &amp.
lambada表达式
涂作权的博客
08-31 3058
lambda表达式 //C++ 11中的Lambda表达式用于定义并创建匿名的函数对象，以简化编程工作。Lambda的语法形式如下： //[函数对象参数](操作符重载函数参数)mutable或exception声明->返回值类型{ 函数体 }   //可以看到，Lambda主要分为五个部分： //[函数对象参数]、(操作符重载函数参数)、
C++避坑---lambda表达式变量的捕获与mutable关键字
jianmo的博客
04-12 203
C++避坑---lambda表达式变量的捕获与mutable关键字
浅析C++11新特性的Lambda表达式
09-01
C++11引入的Lambda表达式是语言更新中的一大亮点，它使得代码更加简洁和高效。Lambda表达式允许程序员在需要的地方直接定义匿名函数，无需预先声明或定义一个单独的函数。这种特性在处理函数对象时特别有用，尤其是...
C++11新特性：Lambda表达式.pdf
10-20
C++11新特性：Lambda表达式 Lambda表达式是C++11新特性中的一种，全新的特性听起来很深奥，但却是很多其他语言早已提供（比如C#）或者即将提供（比如Java）的。Lambda表达式就是用于创建匿名函数的，GCC 4.5.x和...
一文读懂c++11 Lambda表达式
01-19
C++11新增了很多特性，Lambda表达式（Lambda expression）就是其中之一，很多语言都提供了 Lambda 表达式，如 Python，Java ，C#等。本质上， Lambda 表达式是一个可调用的代码单元[1]^{[1]}[1]。实际上是一个闭包...
C++11 lambda表达式
12-22
C++11中的lambda表达式是一种强大的特性，它允许程序员在代码中定义匿名函数，这些函数可以在需要的地方直接使用，而无需预先声明。这极大地方便了代码的编写，特别是对于那些只用一次的函数，同时也增加了代码的...
C++进阶(八) :Lambda 表达式及底层实现原理【详解】
王木木
12-29 6968
一、Lambda简介 lambda表达式是C++11中引入的一项新技术，利用lambda表达式可以编写内嵌的匿名函数，用以替换独立函数或者函数对象，并且使代码更可读。 Lambda 表达式完整的格式如下： [捕获列表] (形参列表) mutable 异常列表-> 返回类型 { 函数体 } 各项的含义： 捕获列表：捕获外部变量，捕获的变量可以在函数体中使用（可省略，即不捕获外部变量） []：默认不捕获任何变量； [=]：默认以值捕获所有变量； [&]：默认以引用捕
C++之mutable
kxlalala的博客
11-28 852
mutable大概两种用法
C++ lambda表达式 （二）
heshaai6843的博客
07-22 365
#include &lt;functional&gt; #include &lt;iostream&gt; int main() { using namespace std; int i = 3; int j = 5; // The following lambda expression captures i by value and // j by...
【C++学习笔记】lambda表达式的mutable
qq_42961603的博客
02-08 1574
【代码】【C++学习笔记】lambda表达式的mutable。
c++ lamuda表达式mutable
流媒体巅峰之路
08-26 5574
1.lambda表达式 C++11引入了Lambda表达式。Lambda表达式的引入，方便了简短函数的定义，为常用的一次性函数的定义和使用提供了很大的便利。 Lambda表达式实际上是一种匿名函数定义，常用来定义简单和不重复使用的函数。其可使用的外部变量、定义方式等都与常规函数有所不同。 auto f = [捕获参数列表](函数参数列表) mutable throw(类型)->返回值类型 {函数语句}; Lambda表达式的定义结构分为六个部分： 函数对象参数部分，Lambd...
C++11
lcl_032015的博客
01-22 123
C++11 1. 智能指针 看的是 STL里面的智能指针 , std::下面的. auto_ptr , unique_ptr , shared_ptr , weak_ptr. C++ 可以控制堆区空间, 手动申请, 手动释放. 遗忘 , 没释放 , 后果, 内存泄露. 可不可以自动释放? --> 智能指针. C++ 封装类, 就是对象, 生命周期结束时, 触发析构, 自然回收空间. 使用智能指针, 可以一定程度上方便编程 , 避免手动回收. auto_ptr , unique_ptr , shared
如何调用DLL
悠悠茹的小窝
03-30 1670
三种使用DLL的方式：#import, #pragma comment, LoadLibrary ，他们之间的区别： #import 用户从类型库中结合信息，该类型库的内容被转换为C++类，主要用于描述COM界面 #pragma comment 一般是静态加载DLL时（对应的头文件、DLL，和LIB缺一不可，并且生产的EXE没有找到DLL文件就会导致“应用程序初始化失败”） LoadLibr...
【C++】使用可变lambda, mutable关键字
热门推荐
Trouble_provider的博客
05-24 1万+
默认情况下，对于一个值被拷贝的变量，lambda不会改变其值，如果我们希望能改变一个被捕获变量的值，就必须在参数列表尾加上关键字mutable。 此处的意思是，默认lambda使用值捕获时，之后在lambda函数体内，使用被值捕获的变量时，该变量值将永远是其被捕获时，被lambda看到的值，一般这个值是无法改变的。 如果加上mutable，则会使得该“值捕获变量”的值，可以在被捕获的值的基础上...
C++11 Lambda 表达式中值传递引入mutable
二进制君
12-04 2304
待编辑 https://www.zhihu.com/question/64969053/answer/226383958
lambda表达式用法与注意点
小麦大大博客
04-25 1399
基本语法 简单来说，Lambda函数也就是一个函数，它的语法定义如下： capture mutable ->return-type{statement} 1.[capture]：捕捉列表。捕捉列表总是出现在Lambda函数的开始处。实际上，[]是Lambda引出符。编译器根据该引出符判断接下来的代码是否是Lambda函数。捕捉列表能够捕捉上下文中的变量以供Lambda函数使用; 2.(p...
C++11 中的 lambda 表达式
最新发布
06-13
C++11 中的 lambda 表达式是一种匿名函数，它可以在任何需要函数对象的地方使用。lambda 表达式以方便的方式定义了一个可调用对象，它可以捕获其所在作用域中的变量，并提供一个函数体，用于执行某些操作。lambda 表达式的一般语法如下： ``` [capture list](parameter list) mutable exception -> return type { // Function body } ``` 其中，`capture list` 用于指定要捕获的外部变量；`parameter list` 用于指定函数参数；`mutable` 用于指定是否允许修改捕获的变量；`exception` 用于指定可能抛出的异常类型；`return type` 用于指定返回值类型。lambda 表达式的函数体可以包含任意有效的 C++ 语句，包括其他 lambda 表达式。 lambda 表达式的优点在于它们可以轻松地定义行为参数化的函数对象，从而使代码更加简洁易读。在异步编程中，lambda 表达式也可以用于指定异步操作的回调函数，从而避免了传统的回调函数指针方式编写的缺点。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值