C++ :lambda表达式

西西最努力

已于 2023-12-15 17:29:58 修改

阅读量992

点赞数 19

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

于 2023-12-15 17:27:30 首次发布

本文链接：https://blog.csdn.net/weixin_42195999/article/details/134989994

版权

C/C++学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

参考：
C++ Lambda表达式详解
 【C++】 Lambda表达式详解
 C++ lambda表达式详解__CSDN_牛马不分
 Qt中使用Lambda表达式
 QT学习笔记（六）利用lambda表达式

一、lambda表达式介绍

c++11引入了Lambda表达式，使得开发人员可以更方便的创建匿名函数。Lambda表达式是c++语言的一个重要特性，它可以作为函数对象使用，可以用来替代一些繁琐的函数声明和定义

二、lambda表达式语法

1、语法格式

[capture list](parameters)mutable exception-> return type{ body };

capture list：捕获列表，在C++规范中也称为Lambda导入器。[]是Lambda引出符。编译器根据该引出符判断接下来的代码是否是Lambda函数。
parameters：参数列表（可选），与普通函数的参数列表一致。如果不需要参数传递，则可以连同括号“()”一起省略。
mutable：可变规格（可选），mutable修饰符，默认情况下Lambda函数总是一个const函数，mutable可以取消其常量性。在使用该修饰符时，参数列表不可省略（即使参数为空）。
exception：异常说明（可选），用于Lamdba表达式内部函数抛出异常。
return type：返回值类型（可选），追踪返回类型形式声明函数的返回类型。我们可以在不需要返回值的时候也可以连同符号”->”一起省略。此外，在返回类型明确的情况下，也可以省略该部分，让编译器对返回类型进行推导。
body：函数体，内容与普通函数一样，不过除了可以使用参数之外，还可以使用所有捕获的变量。

2、捕获列表

引出符	含义
[]	不捕获任何变量
[=]	lambda所在范围内所有可见的局部变量，包括this。采用值传递。
[&]	lambda所在范围内所有可见的局部变量，包括this。采用引用传递。
[this]	lambda所在类的成员变量
[a]	将a按值传递，传递时不能修改传递进来的a的拷贝，因为默认情况下是const，要修改传递进来的a拷贝，可以添加mutable修饰符
[&a]	将a按引用进行传递
[a,&b]	a按值传递，b按引用传递
[=,&a,&b]	除a和b按引用传递，其他参数按值传递
[&,a,b]	除a和b按值传递，其他参数按引用传递

3 不捕获任何变量

[]

基本的lambda表达式

	auto str =[](){
	    cout << "Hello world!" << endl;
	};
	str();
	//输出：Hello world!

带参数的lambda表达式

    auto add =[](int a,int b){
        cout << "add: " << a+b << endl;
    };
    add(13,85);
    //输出：add: 98

带返回值的lambda表达式

    auto mult = [](int a,int b){
        return a*b;
    };
    cout << "mult : " << mult(13,85) << endl;
    auto dret = [](int a,int b,bool op){
        if(op)
            return a*b;
        else
            return a+b;
    };
    cout << "DRet : " << dret(3,2,false) << endl;
    //输出：mult : 1105
    //输出：DRet : 5

4 值传递

[var]
[this]
[=]

基本的lambda表达式

    int v1 = 100;
    auto getvalue = [v1](){
        cout << "getvalue: " << v1 <<endl;
    };
    getvalue();
    int v2 = 22;
    auto getvalue2 = [v1,v2](){
        cout << "getvalue2: " <<v1*v2 <<endl;
    };
    getvalue2();
    //输出：getvalue: 100
    //输出：getvalue2: 2200

带参数的lambda表达式

	auto getvalue_parm = [v1](int v2){
        cout << "getvalue_parm: " << v1+v2 <<endl;
    };
    getvalue_parm(32);
    //输出：getvalue_parm: 132

带返回值的lambda表达式

    auto getvalue_ret = [v1,v2]{
        return (v1+v2)/2;
    };
    cout << "getvalue_ret: " << getvalue_ret() <<endl;
    //输出：getvalue_ret: 61

隐式按值捕获所有变量的lambda表达式

    auto hidevalue = [=](){
        cout << "hidevalue: "<< v1/v2 << endl;
    };
    hidevalue();
    //输出：hidevalue: 4

捕获所在类的成员变量的lambda表达式

	int c = 35;  //类的成员变量，而非函数内的局部变量
	//auto thisvalue = [](){   //error
    auto thisvalue = [this](){
        cout << "thisvalue: " << c << endl;
    };
    thisvalue();
    //输出：thisvalue: 34

5 引用传递

[&var]
[&]

基本的lambda表达式

    int num = 44;
    auto quote = [&num](){
        num++;
    };
    quote();
    cout << "quote: " << num << endl;
    //输出:quote: 45

带参数的lambda表达式

    auto quote_parm = [&num](int a){
        num += a;
    };
    quote_parm(15);
    cout << "quote_parm: " << num << endl;
    //输出：quote_parm: 60

带返回值的lambda表达式

    auto quote_ret = [&num](){
        num ++ ;
        return num;
    };
    cout << "quote_ret: "<< quote_ret() << endl;
    //输出：quote_ret: 61

隐式按值捕获所有变量的lambda表达式

    int num2 = 35;
    auto hidequote =[&](){
        num++;
        num2 += num;
    };
    hidequote();
    cout << "hidequote: "<< num << " " << num2 <<endl;
    //输出：hidequote: 62 97

6 拷贝与引用混合

[=, &a, &b]
[&, a, this]

    auto vq = [=,&v1,&v2]()
    {
        cout << "vq: " << "v1:" << v1 << " v2:" << v2   <<" num:"<<num
             << " num2:" << num2 <<endl;
        v1++;
        v2++;
        cout << "vq: " << "v1:" << v1 << " v2:" << v2   <<" num:"<<num
             << " num2:" << num2 <<endl;

    };
    vq();
    //输出：vq: v1:100 v2:22 num:62 num2:97
	//输出：vq: v1:101 v2:23 num:62 num2:97

   auto vq2 = [&,v1,this]()
    {
        cout << "vq2: " << "v1:" << v1 << " v2:" << v2   <<" num:"<<num
             << " num2:" << num2 << " c:" << c << endl;
        v2++;
        num +=2;
        num2 += 2;
        c += 2;
        cout << "vq2: " << "v1:" << v1 << " v2:" << v2   <<" num:"<<num
             << " num2:" << num2 << " c:" << c << endl;

    };
    vq2();
    //输出：vq2: v1:101 v2:23 num:62 num2:97 c:34
	//输出：vq2: v1:101 v2:24 num:64 num2:99 c:36

[=, a]错误的捕获，重复捕捉了a
[&,&this]错误的捕获，重复捕捉了this

总结

class A{
public:
    int i = 0 ;
    void func(int x,int y)
    {
        auto x1 = [](){ return i; };            // error，没有捕获外部变量
        auto x2 = [=](){ return i+x+y;};        // OK，捕获所有外部变量
        auto x3 = [&](){ i++; return i+x+y;};   // OK，捕获所有外部变量
        auto x4 = [this](){ return i; };        // OK，捕获this指针
        auto x5 = [this](){ return x+y; };      // error，没有捕获x、y
        auto x6 = [this,x,y](){ return i+x+y;}; // OK，捕获this指针、x、y
        auto x7 = [this](){return i++;};        // OK，捕获this指针，并修改成员的值
    }
};
void func2(){
    int a = 0, b = 1;
    auto f1 = []{ return a; };               // error，没有捕获外部变量
    auto f2 = [&]{ return a++; };            // OK，捕获所有外部变量，并对a执行自加运算
    auto f3 = [=]{ return a; };              // OK，捕获所有外部变量，并返回a
    auto f4 = [=]{ return a++; };            // error，a是以复制方式捕获的，无法修改
    auto f5 = [a]{ return a + b; };          // error，没有捕获变量b
    auto f6 = [a, &b]{ return a + (b++); };  // OK，捕获a和b的引用，并对b做自加运算
    auto f7 = [=, &b]{ return a + (b++); };  // OK，捕获所有外部变量和b的引用，并对b做自加运算
}

三、lambda表达式的使用

与algorithm相结合

for_each 遍历

    vector<int> vec ={6,9,0,8,2,4,10,1,5};
    //for_each
    cout << "for_each: ";
    for_each(vec.begin(),vec.end(),[](int n){
        cout << n << " ";
        return n;
    });
    cout << endl;
    //输出：for_each: 6 9 0 8 2 4 10 1 5

sort 排序

    sort(vec.begin(),vec.end(),[](int a,int b){
        return a>b;
    });
    cout << "sort: " ;
    for( auto v1 :vec)
    {
        cout << v1 << " ";
    }
    cout << endl;
    //输出：sort: 10 9 8 6 5 4 2 1 0

copy 复制

    cout << "copy: ";
    copy(vec.begin(), vec.end(), ostream_iterator<int>(cout, " ")); //ostream_iterator<int>(cout, " ") 创建一个输出流迭代器，设置分隔符
    cout << endl;
    //输出：copy: 10 9 8 6 5 4 2 1 0

find_if 查找

    vector<int> vec2 ={6,9,0,8,2,4,10,1,5};
    auto iter = find_if(vec2.begin(),vec2.end(),[](int a)		{
        return a > 5;
    });
    if(iter == vec2.end())
    {
        cout << "find_if :not found!" << endl;
    }
    else{
        //输出>5的第一个数
        cout << "find_if: " << *iter <<" " << endl;
        //输出>5的第一个数后面所有的数，而不是所有>5的数
        cout <<  "find_if2: ";
        while(iter != vec2.end())
        {
            cout  << *iter++ << " " ;
        }
        cout << endl;
    }
    //输出：find_if: 6 
	//输出：find_if2: 6 9 0 8 2 4 10 1 5

remove_if 移除

    auto reif = remove_if(vec2.begin(),vec2.end(),[](int n)
    {
        return n<5;
    });
    vec2.erase(reif,vec2.end());
    cout << "remove_if: ";
    for(auto v:vec2)
    {
        cout << v <<" ";
    }
    cout << endl;
    //输出：remove_if: 6 9 8 10 5

多线程中的使用

    std::thread tthread001([](int x)
    {
       cout << x << endl;
    }, 30);
    tthread001.join();

 // vector 容器存储线程
    std::vector<std::thread> workers;
    for (int i = 0; i < 5; i++)
    {
        workers.push_back(std::thread([]()
        {
            std::cout << "thread function\n";
        }));
    }
    std::cout << "main thread\n";

    // 通过 for_each 循环每一个线程
    // 第三个参数赋值一个task任务
    // 符号'[]'会告诉编译器我们正在用一个匿名函数
    // lambda函数将它的参数作为线程的引用t
    // 然后一个一个的join
    std::for_each(workers.begin(), workers.end(), [](std::thread &t)
    {
        t.join();
    });

西西最努力

关注

19
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
C++ :lambda表达式

c++11引入了Lambda表达式，使得开发人员可以更方便的创建匿名函数。Lambda表达式是c++语言的一个重要特性，它可以作为函数对象使用，可以用来替代一些繁琐的函数声明和定义class A{public:int i = 0;// error，没有捕获外部变量// OK，捕获所有外部变量// OK，捕获所有外部变量// OK，捕获this指针// error，没有捕获x、y// OK，捕获this指针、x、y// OK，捕获this指针，并修改成员的值。
复制链接

扫一扫