＜C++＞ C++11 Lambda表达式

news2024/12/30 4:12:29

C++11 Lambda表达式

1.C++98中的一个例子

在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法。

#include <algorithm>
#include <functional>
int main() {
    int array[] = {4, 1, 8, 5, 3, 7, 0, 9, 2, 6};
    // 默认按照小于比较，排出来结果是升序
    std::sort(array, array + sizeof(array) / sizeof(array[0]));
    // 如果需要降序，需要改变元素的比较规则
    std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());
    return 0;
}

如果待排序元素为自定义类型，需要用户定义排序时的比较规则：

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

struct Goods {
    string _name; // 名字
    double _price;// 价格
    int _evaluate;// 评价
    Goods(const char *str, double price, int evaluate)
        : _name(str), _price(price), _evaluate(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 = {{"苹果", 2.1, 5}, {"香蕉", 3, 4}, {"橙子", 2.2, 3}, {"菠萝", 1.5, 4}};
    sort(v.begin(), v.end(), ComparePriceLess());
    sort(v.begin(), v.end(), ComparePriceGreater());
}

随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法， 都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名， 这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式。

2.Lambda表达式

Lambda表达式是C++11标准引入的一种匿名函数的方式。它提供了一种简洁、灵活的语法，可以在需要函数对象的地方定义和使用函数。

Lambda表达式的基本语法如下：

[capture-list](parameter-list) -> return-type { 
    // 函数体
}

其中，各部分的含义如下：

  • capture-list：指定要在lambda表达式中捕获的变量。捕获可以是值捕获（通过复制变量的值进行捕获）或引用捕获（通过引用绑定到变量）。捕获列表是可选的，如果没有捕获任何变量，则可以省略。
  • parameter-list：指定lambda函数的参数列表，与普通函数的参数列表相似。参数列表是可选的，如果函数不需要参数，则可以省略。
  • return-type：指定lambda函数的返回类型。返回类型可以省略，编译器会自动推导出返回类型。
  • {}：lambda函数体的起始和结束标记。

上述代码可以使用C++11中的lambda表达式来解决

struct Goods {
    string _name; // 名字
    double _price;// 价格
    int _evaluate;// 评价
    Goods(const char *str, double price, int evaluate)
        : _name(str), _price(price), _evaluate(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 = {{"苹果", 2.1, 5}, {"香蕉", 3, 4}, {"橙子", 2.2, 3}, {"菠萝", 1.5, 4}};
    sort(v.begin(), v.end(), [](const Goods &g1, const Goods &g2) {
        return g1._price < g2._price;
    });
    sort(v.begin(), v.end(), [](const Goods &g1, const Goods &g2) {
        return g1._price > g2._price;
    });
    sort(v.begin(), v.end(), [](const Goods &g1, const Goods &g2) {
        return g1._evaluate < g2._evaluate;
    });
    sort(v.begin(), v.end(), [](const Goods &g1, const Goods &g2) {
        return g1._evaluate > g2._evaluate;
    });
}

可以看出lambda表达式实际是一个匿名函数。

注意：

在Lambda表达式定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的Lambda表达式为：[]{}; 该Lambda表达式不能做任何事情。

int main() {
    // 最简单的lambda表达式, 该lambda表达式没有任何意义
    [] {};

    // 省略参数列表和返回值类型，返回值类型由编译器推导为int
    int a = 3, b = 4;
    [=] { return a + 3; };

    // 省略了返回值类型，无返回值类型
    auto fun1 = [&](int c) { b = a + c; };
    fun1(10);
    cout << a << " " << b << endl;

    // 各部分都很完善的lambda函数
    auto fun2 = [=, &b](int c) -> int { return b += a + c; };

    //cout << [=, &b](int c) -> int { return b += a + c; }(10);
    cout << fun2(10) << endl;

    // 复制捕捉x
    int x = 10;
    auto add_x = [x](int a) mutable { x *= 2; return a + x; };
    cout << add_x(10) << endl;
    return 0;
}

通过上述例子可以看出，Lambda表达式实际上可以理解为无名函数，该函数无法直接调用，如果想要直接调用，可借助auto将其赋值给一个变量。

捕获列表说明

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

  • [var]：表示值传递方式捕捉变量var
  • [=]：表示值传递方式捕获所有父作用域中的变量(包括this)
  • [&var]：表示引用传递捕捉变量var
  • [&]：表示引用传递捕捉所有父作用域中的变量(包括this)
  • [this]：表示值传递方式捕捉当前的this指针
  1. [var]：表示值传递方式捕获变量 var。Lambda函数会复制变量 var 的值，以便在函数体中使用。修改Lambda函数内部的变量 var 不会影响外部的变量。
int x = 5;

auto Lambda = [x]() {
    // 使用值传递方式捕获的变量x
    std::cout << "Value of x: " << x << std::endl;
};

x = 10; // 修改外部变量x的值

Lambda(); // 输出: Value of x: 5

在上述示例中，Lambda函数通过值传递方式捕获了变量 x 的值。即使在Lambda函数外部修改了变量 x 的值，Lambda函数内部使用的是捕获时的复制，所以输出结果仍然是捕获时的值。

  1. [=]：表示值传递方式捕获所有父作用域中的变量（包括 this）。Lambda函数会复制所有的外部变量的值，以便在函数体中使用。这样，Lambda函数可以在没有副作用的情况下访问所有的外部变量。
int x = 5;
int y = 10;

auto lambda = [=]() {
    // 使用值传递方式捕获的变量x和y
    std::cout << "Value of x: " << x << std::endl;
    std::cout << "Value of y: " << y << std::endl;
};

x = 20;
y = 30;

lambda(); // 输出: Value of x: 5  Value of y: 10

在上述示例中，Lambda函数通过值传递方式捕获了变量 x 和 y 的值。即使在Lambda函数外部修改了变量的值，Lambda函数内部使用的是捕获时的复制，所以输出结果仍然是捕获时的值。

​ 3.[&var]：表示引用传递捕获变量 var。Lambda函数通过引用绑定到变量 var，以便在函数体中使用。对变量 var 的修改会影响外部的变量。

int x = 5;

auto lambda = [&x]() {
    // 使用引用传递方式捕获的变量x
    std::cout << "Value of x: " << x << std::endl;
};

x = 10; // 修改外部变量x的值

lambda(); // 输出: Value of x: 10

在上述示例中，Lambda函数通过引用传递方式捕获了变量 x。因为是通过引用绑定到变量，所以在Lambda函数内部访问的是同一个变量，所以输出结果会反映变量修改后的值。

  1. [&]：表示引用传递捕获所有父作用域中的变量（包括 this）。Lambda函数通过引用绑定到所有的外部变量，以便在函数体中使用。对变量的修改会影响外部的变量。
int x = 5;
int y = 10;

auto lambda = [&]() {
    // 使用引用传递方式捕获的变量x和y
    std::cout << "Value of x: " << x << std::endl;
    std::cout << "Value of y: " << y << std::endl;
};

x = 20;
y = 30;

lambda(); // 输出: Value of x: 20  Value of y: 30

在上述示例中，Lambda函数通过引用传递方式捕获了变量 x 和 y。因为是通过引用绑定到变量，所以在Lambda函数内部访问的是同一个变量，所以输出结果会反映变量修改后的值。

  1. [this]：表示值传递方式捕获当前的 this 指针。Lambda函数会复制当前对象的 this 指针，以便在函数体中使用。通过捕获 this，Lambda函数可以访问当前对象的成员变量和成员函数。
class MyClass {
public:
    void foo() {
        auto lambda = [this]() {
            // 使用值传递方式捕获的当前对象的this指针
            std::cout << "Value of member: " << member << std::endl;
            bar(); // 调用成员函数
        };

        lambda();
    }

private:
    int member = 5;

    void bar() {
        std::cout << "Inside bar()" << std::endl;
    }
};

MyClass obj;
obj.foo(); // 输出: Value of member: 5  Inside bar()

在上述示例中，Lambda函数通过值传递方式捕获了当前对象的 this 指针，并使用该指针访问了成员变量 member 和成员函数 bar()。

int main() {
    int x = 0, y = 1;
    int m = 0, n = 1;

    auto swap1 = [](int &rx, int &ry) {
        int tmp = rx;
        rx = ry;
        ry = tmp;
    };

    swap1(x, y);
    cout << x << " " << y << endl;

    // 传值捕捉
    auto swap2 = [x, y]() mutable {
        int tmp = x;
        x = y;
        y = tmp;
    };

    swap2();
    cout << x << " " << y << endl;

    // 引用捕捉
    auto swap2 = [&x, &y]() {
        int tmp = x;
        x = y;
        y = tmp;
    };

    swap2();
    cout << x << " " << y << endl;

    // 混合捕捉
    auto func1 = [&x, y]() {
        //...
    };

    // 全部引用捕捉
    auto func2 = [&]() {
        //...
    };

    // 全部传值捕捉
    auto func3 = [=]() {
        //...
    };

    // 全部引用捕捉，x传值捕捉
    auto func4 = [&, x]() {
        //...
    };

    return 0;
}

注意：

a. 父作用域指包含lambda函数的语句块

b. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。 比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量 [&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量

c. 捕捉列表不允许变量重复传递，否则就会导致编译错误。 比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复

d. 在块作用域以外的lambda函数捕捉列表必须为空。

e. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者 非局部变量都会导致编译报错

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

void (*PF)();
int main() {
    auto f1 = [] { cout << "hello world" << endl; };
    auto f2 = [] { cout << "hello world" << endl; };
    // 此处先不解释原因，等lambda表达式底层实现原理看完后，大家就清楚了
    //f1 = f2;   // 编译失败--->提示找不到operator=()
    // 允许使用一个lambda表达式拷贝构造一个新的副本
    auto f3(f2);
    f3();
    // 可以将lambda表达式赋值给相同类型的函数指针
    PF = f2;
    PF();
    return 0;
}

mutable

mutable是一个关键字，用于修饰Lambda表达式，表示Lambda函数体内的可变状态。默认情况下，Lambda函数体中捕获的变量是只读的，不允许修改。然而，有时候我们可能需要在Lambda函数体中修改这些变量的值，这就需要使用mutable关键字。

使用mutable关键字修饰Lambda函数后，可以在函数体内修改被捕获的变量。这对于需要在Lambda函数中维护一些内部状态或计数器等情况非常有用。

#include <iostream>

int main() {
    int x = 0;

    auto lambda = [x]() mutable {
        x++;// 修改被捕获的变量x
        std::cout << "Value of x: " << x << std::endl;
    };

    /*  auto lambda = [&x]() {
        x++; // 修改被捕获的变量x
        std::cout << "Value of x: " << x << std::endl;
    } */

    lambda();// 输出: Value of x: 1
    lambda();// 输出: Value of x: 2

    std::cout << "Final value of x: " << x << std::endl;// 输出: Final value of x: 0

    return 0;
}

在上述示例中，Lambda函数通过值传递方式捕获了变量 x。由于使用了mutable关键字修饰，Lambda函数体内部可以修改被捕获的变量 x 的值。每次调用Lambda函数，x 的值都会递增，并输出相应的结果。

需要注意的是，mutable关键字只对Lambda函数体内的变量生效，对于通过引用传递方式捕获的变量，mutable不起作用。

使用mutable关键字需要谨慎，因为它使Lambda函数具有副作用，可能导致意外的结果。在使用mutable时，务必确保修改被捕获的变量不会引发竞态条件或其他问题。

3.函数对象与Lambda表达式

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

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

从使用方式上来看，函数对象与lambda表达式完全一样。

函数对象将rate作为其成员变量，在定义对象时给出初始值即可，Lambda表达式通过捕获列表可以直接将该变量捕获到。
在这里插入图片描述
实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个Lambda表达式，编译器会自动生成一个类(每次生产的类编号都不一样)，在该类中重载了operator()。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/674221.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

软考：软件工程:面向对象技术与UML，时序图，用例图，类对象，封装，继承，多态

软考：软件工程:面向对象技术与UML，时序图，用例图，类对象，封装，继承，多态

软考&#xff1a;软件工程: 提示&#xff1a;系列被面试官问的问题&#xff0c;我自己当时不会&#xff0c;所以下来自己复盘一下&#xff0c;认真学习和总结&#xff0c;以应对未来更多的可能性 关于互联网大厂的笔试面试&#xff0c;都是需要细心准备的 &#xff08;1&#…
阅读更多...
iOS 集成Jenkins pipeline 完整流程

iOS 集成Jenkins pipeline 完整流程

文章目录 一 创建一个Jenkins pipeline 项目配置分支参数在工程中添加 ExportOptions.plist 文件创建放置打包文件的文件夹在工程里面添加shell脚本文件配置pipeline sript构建 一 创建一个Jenkins pipeline 项目 配置分支参数 选择参数化构建构成&#xff0c;如上图所示&#…
阅读更多...
网络层实验报告

网络层实验报告

计算机网络综合实训 实训报告二 所在院系 计算机与信息工程学院 学科专业名称 计算机科学与技术 导师及职称 柯宗武 教授 提交时间 2022.3.29 网络层实验报告 &#xff08;湖北师范大学计算机与信息工程学院 中国 黄石 435002&#xff09; 1 IP分析 1.1背景知识 1.1.1 什么是…
阅读更多...
SpringMVC系列-2 HTTP请求调用链

SpringMVC系列-2 HTTP请求调用链

背景 本文作为 SpringMVC系列 第二篇&#xff0c;介绍HTTP请求的调用链&#xff1a;从请求进入Tomcat到数据流返回客户端的完整过程。为了尽可能把流程表达清楚&#xff0c;进行了很多减支处理&#xff0c;只关注主线逻辑。 本文也作为SpringMVC系列后续文章的基础&#xff0…
阅读更多...
软考A计划-系统集成项目管理工程师--一般常识-上

软考A计划-系统集成项目管理工程师--一般常识-上

点击跳转专栏>Unity3D特效百例点击跳转专栏>案例项目实战源码点击跳转专栏>游戏脚本-辅助自动化点击跳转专栏>Android控件全解手册点击跳转专栏>Scratch编程案例点击跳转>软考全系列 &#x1f449;关于作者 专注于Android/Unity和各种游戏开发技巧&#xff…
阅读更多...
SpringBoot 异常处理的主要组件有哪些

SpringBoot 异常处理的主要组件有哪些

SpringBoot 异常处理的主要组件有哪些 在 SpringBoot 应用程序中&#xff0c;异常处理是一个非常重要的话题。当应用程序出现异常时&#xff0c;我们需要对异常进行处理&#xff0c;以保证应用程序的稳定性和可靠性。SpringBoot 提供了一系列的组件&#xff0c;用于处理各种类…
阅读更多...
简析IAST—Agent篇 | 信息安全

简析IAST—Agent篇 | 信息安全

一、IAST简单介绍 IAST(Interactive Application Security Testing)交互式应用程序安全测试&#xff0c;通过服务端部署Agent探针&#xff0c;流量代理/VPN或主机系统软件等方式&#xff0c;监控Web应用程序运行时函数执行并与扫描器实时交互&#xff0c;高效、精准的安全漏洞&…
阅读更多...
LeetCode 面试题 16.19. 水域大小

LeetCode 面试题 16.19. 水域大小

LeetCode 面试题 16.19. 水域大小 来源&#xff1a;力扣&#xff08;LeetCode&#xff09; 链接&#xff1a;https://leetcode.cn/problems/group-anagrams/description/ 博主Github&#xff1a;https://github.com/GDUT-Rp/LeetCode 题目&#xff1a; 你有一个用于表示一片…
阅读更多...
C++初阶之初识C++

C++初阶之初识C++

初识C 1.什么是C2.C的发展史2.1 历史渊源2.2 名称由来2.3 C标准 3.C的重要性3.1 语言的使用广泛度3.2 工作领域 4.如何学习C5.结语 1.什么是C C语言是结构化和模块化的语言&#xff0c;适合处理较小规模的程序。对于复杂的问题&#xff0c;规模较大的 程序&#xff0c;需要高度…
阅读更多...
【k8s系列】一分钟搭建MicroK8s Dashboard

【k8s系列】一分钟搭建MicroK8s Dashboard

本文基于上一篇文章的内容进行Dashboard搭建&#xff0c;如果没有看过上一篇的同学请先查阅上一篇文章 k8s系列】使用MicroK8s 5分钟搭建k8s集群含踩坑经验 使用MicroK8s搭建Dashboard很简单&#xff0c;只需要在Master节点按照以下几步操作 1.启用Dashboard插件 microk8s en…
阅读更多...
“Vue3+Vite打包后，白屏沉默，重启重试无果，我该如何解决？”

“Vue3+Vite打包后，白屏沉默，重启重试无果，我该如何解决？”

每次最后打包总是会或多或少出现一些问题&#xff0c;昨天打包项目完之后 直接点击dist中的index.html去看看有没有什么发题&#xff0c;一打开奇怪的事发生了&#xff0c;居然是空白&#xff1b;但是在vscode中右键Open with Live Server一看项目没啥问题&#xff0c;但是部署…
阅读更多...
下载安装Python解释器和环境变量配置

下载安装Python解释器和环境变量配置

一、 python解释器下载 1.百度python官网并打开 官网网址&#xff1a;https://www.python.org/ 在这里插入图片描述 2.选择DownLoads&#xff0c;Windows并打开 3.在下图页面选择你需要的版本下载即可&#xff08;本文以python 3.10.4版本演示&#xff09; 在这里插入图片描述 …
阅读更多...
C++笔记之extern关键字

C++笔记之extern关键字

C笔记之extern关键字 code review! 文章目录 C笔记之extern关键字0.前言1.extern是C语言的关键字还是C中的关键字&#xff1f;2.extern关键字和全局变量3.ChatGpt讲述extern的用法4.extern一般用法4.1.在本模块中使用4.2.跨模块中使用 5.标准定义使用extern关键字的步骤7.ext…
阅读更多...
Nginx 访问日志中有 Get 别的网站的请求是什么原因？

Nginx 访问日志中有 Get 别的网站的请求是什么原因？

&#x1f482; 个人网站:【海拥】【游戏大全】【神级源码资源网】&#x1f91f; 前端学习课程&#xff1a;&#x1f449;【28个案例趣学前端】【400个JS面试题】&#x1f485; 寻找学习交流、摸鱼划水的小伙伴&#xff0c;请点击【摸鱼学习交流群】 目录 前言理解 Nginx 访问日…
阅读更多...
父亲的打，最让人想念。

父亲的打，最让人想念。

11年前的端午节&#xff0c;父亲就走了。 父亲十五岁就外出打工&#xff0c;从小出去打工&#xff0c;吃了没有文化的苦&#xff0c;父亲从小教育我要好好读书&#xff0c;可我从来听不进。 所以我经常挨打。 老家在湖南的一个农村&#xff0c;我父亲十几岁就南下打工&#xff…
阅读更多...
[进阶]网络通信：TCP通信，一发一收，多发多收

[进阶]网络通信：TCP通信，一发一收，多发多收

TCP通信 特点&#xff1a;面向连接、可靠通信。通信双方事先会采用 “三次握手〞 方式建立可靠连接&#xff0c;实现端到端的通信&#xff1b;底层能保证数据成功传给服务端。Java提供了一个java.net.socket类来实现TCP通信。 TCP通信——客户端开发 客户端程序就是通过java.…
阅读更多...
基于OpenCV-车辆检测项目（简易版）

基于OpenCV-车辆检测项目（简易版）

车辆检测 1.项目介绍2. 读取一段视频3.通过形态学处理识别车辆4.描画轮廓5. 车辆计数并显示 本项目使用的视频地址链接 1.项目介绍 对一个视频进行车辆数量的检测&#xff0c;用到的知识有视频的读取&#xff0c;滤波器&#xff0c;形态学&#xff0c;添加直线、文本&#xff…
阅读更多...
黑马头条2

黑马头条2

文章目录 前言一、接口工具1.1 postman1.2 swagger1.3 knife4j 二、 网关一、基本搭建二、全局过滤器jwt 三、 前端集成导入前端工程项目安装nginx测试 &#x1f315;博客x主页&#xff1a;己不由心王道长&#x1f315;! &#x1f30e;文章说明&#xff1a;黑马头条开发&#x…
阅读更多...
一站式数据可观测性平台 Datavines 正式开源啦

一站式数据可观测性平台 Datavines 正式开源啦

Datavines是一站式开源数据可观测性平台&#xff0c;提供元数据管理、数据概览报告、数据质量管理&#xff0c;数据分布查询、数据趋势洞察等核心能力&#xff0c;致力于帮助用户全面地了解和掌管数据&#xff0c;让您做到心中有数&#xff0c;目前作为 Datavane 开源组织的重点…
阅读更多...
Java ForkJoin 简介和应用

Java ForkJoin 简介和应用

Java 并行框架 Fork Join 一.Fork Join 简介1.框架说明2.任务说明 二.应用示例1.RecursiveTask分组示例分组求和 2.RecursiveAction3.CountedCompleter 三.ForkJoin 实践代码测试1.测试用 Excel 文件2.读取结果 一.Fork Join 简介 1.框架说明 ForkJoinPool 继承自 AbstractEx…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023