【C++】lambda表达式

最新推荐文章于 2024-10-02 08:00:00 发布

木.子

最新推荐文章于 2024-10-02 08:00:00 发布

阅读量909

点赞数 32

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

本文链接：https://blog.csdn.net/qq_51970374/article/details/138892714

版权

C++ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、基础知识

1、lambda表达式的定义和用途

Lambda表达式（也称为λ表达式）是一种简洁地表示可调用对象（如函数或函数对象）的语法。它允许你快速定义一个可以在需要函数对象的任何地方使用的匿名函数。

2、基本语法

在C++中，lambda表达式的基本语法如下：

[capture](parameters) -> return-type { body }

[capture]：捕获子句，定义lambda可以访问的外部变量。它可以包括&（引用捕获）或=（值捕获）或两者都有，以及具体的变量名列表。
(parameters)：参数列表，定义lambda函数的参数。
return-type：可选的返回类型指定符。如果省略，编译器将根据函数体中的代码推断返回类型。
{ body }：函数体，包含lambda函数的实现。

一个简单的lambda表达式示例：

#include <iostream>  
#include <vector>  
#include <algorithm>  
  
int main() {  
    std::vector<int> numbers = {1, 2, 3, 4, 5};  
  
    // 使用lambda表达式打印大于3的数字  
    std::for_each(numbers.begin(), numbers.end(), [](int num) {  
        if (num > 3) {  
            std::cout << num << std::endl;  
        }  
    });  
  
    return 0;  
}

捕获列表：在这个例子中，我们没有使用捕获列表，因为lambda没有访问任何外部变量。但如果有需要，我们可以添加捕获列表，如[&]（通过引用捕获所有外部变量）或[=]（通过值捕获所有外部变量）。
参数列表：int num 是lambda的参数列表，它定义了传递给lambda函数的参数。
函数体：在大括号{}内的代码是lambda的函数体，它包含了lambda函数的实现。在这个例子中，函数体检查num是否大于3，如果是，则打印num。

3、捕获列表的详细说明

捕获列表的类型和含义

[]：不捕获任何变量。
[&]：以引用方式捕获所有外部作用域中的变量（按引用捕获）。
[=]：以值方式捕获所有外部作用域中的变量（按值捕获）。
[x]：仅按值捕获变量x。
[&, x]：以引用方式捕获所有外部作用域中的变量，但以值方式捕获变量x。
[=, &y]：以值方式捕获所有外部作用域中的变量，但以引用方式捕获变量y。

捕获列表的使用场景

当lambda表达式不需要访问外部变量时，可以使用[]。
当需要访问并可能修改外部变量时，可以使用[&]（注意这可能会引入悬挂引用问题）。
当需要捕获多个变量但不想修改它们时，可以使用[=]。
如果只需要捕获特定的变量，并指定捕获方式（值或引用），可以使用如[x]或[&y]这样的捕获列表。

3、常见用途

回调函数：Lambda表达式可以方便地作为回调函数使用，特别是在需要传递函数对象作为参数的API中。
算法参数：在STL（Standard Template
Library）算法中，Lambda表达式可以用作谓词（predicate）或操作（operation），以定义算法的行为。
并行计算：在C++17及以后的版本中，Lambda表达式可以与并行算法库（如）结合使用，以实现并行计算。
简化代码：Lambda表达式可以简化代码结构，使代码更加紧凑和易读。通过将小型的、一次性的函数逻辑嵌入到Lambda表达式中，可以避免定义单独的函数或类。
闭包：Lambda表达式可以捕获其所在作用域中的变量，并在其函数体中使用这些变量。这种特性使得Lambda表达式具有闭包（closure）的能力，即能够记住并访问其定义时的作用域。

二、进阶概念

1、lambda表达式和std::function

std::function：std::function是C++标准库中的一个模板类，它是对函数、lambda表达式、函数对象（functor）等可调用对象的封装，使得它们可以统一地进行存储和调用。std::function类型非常灵活，可以存储任何满足其调用签名的可调用对象。

std::function 是一个模板类，它接受一个签名作为模板参数，该签名描述了被封装的函数接受什么类型的参数，和它应该返回什么类型的值。

std::function<ReturnType(ParamType1, ParamType2, ...)> func;

std::function可以与lambda表达式一起使用，将lambda表达式作为std::function对象进行存储和传递。这是因为lambda表达式是可调用对象，其类型可以隐式地转换为std::function类型（只要它们的调用签名匹配）。使用std::function存储lambda表达式的一个好处是，可以将函数指针、函数对象、成员函数指针和lambda表达式等不同类型的可调用对象统一存储在一个std::function对象中，从而提高代码的灵活性和可重用性。

示例：

#include <iostream>  
#include <functional>  
  
void printSum(const std::function<int(int, int)>& f, int a, int b) {  
    std::cout << "The sum is: " << f(a, b) << std::endl;  
}  
  
int main() {  
    // 普通函数  
    int add(int x, int y) { return x + y; }  
  
    // Lambda 表达式  
    auto multiply = [](int x, int y) { return x * y; };  
  
    // 使用 std::function 封装并调用函数  
    printSum(add, 3, 4);        // 输出 "The sum is: 7"  
    printSum(multiply, 3, 4);   // 输出 "The sum is: 12"（尽管这里用的是乘法，但函数名仍然是 printSum）  
  
    return 0;  
}

在这个示例中，printSum 函数接受一个 std::function 对象作为参数，该对象可以是任何接受两个整数并返回一个整数的可调用对象。这使得 printSum 函数非常灵活，可以接受不同类型的函数和 lambda 表达式作为参数。

2、lambda表达式在STL算法中的使用

Lambda表达式在C++的STL（Standard Template Library）算法中非常有用，因为它们提供了一种简洁、灵活的方式来定义临时的、匿名的函数对象，这些函数对象可以直接作为参数传递给STL算法。下面我将通过几个例子来说明lambda表达式在STL算法中的使用场景。

1. std::find_if

std::find_if算法用于在容器中查找第一个满足特定条件的元素。Lambda表达式非常适合作为这个算法的谓词（predicate）。

#include <algorithm>  
#include <vector>  
#include <iostream>  
  
int main() {  
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9};  
  
    // 使用lambda表达式作为谓词来查找第一个偶数  
    auto is_even = [](int num) { return num % 2 == 0; };  
    auto result = std::find_if(numbers.begin(), numbers.end(), is_even);  
  
    if (result != numbers.end()) {  
        std::cout << "Found even number: " << *result << std::endl;  
    } else {  
        std::cout << "No even number found." << std::endl;  
    }  
  
    return 0;  
}

2. std::for_each

std::for_each算法对容器中的每个元素执行特定的操作。同样，Lambda表达式可以作为这个算法的操作。

#include <algorithm>  
#include <vector>  
#include <iostream>  
  
int main() {  
    std::vector<int> numbers = {1, 2, 3, 4, 5};  
  
    // 使用lambda表达式来打印容器中的每个元素  
    std::for_each(numbers.begin(), numbers.end(), [](int num) {  
        std::cout << num << " ";  
    });  
  
    std::cout << std::endl;  
  
    return 0;  
}

3. std::transform

std::transform算法将容器中的每个元素转换为新的值，并将结果存储在新的容器中（或者覆盖原容器）。Lambda表达式可以用来定义转换逻辑。

#include <algorithm>  
#include <vector>  
#include <iostream>  
#include <iterator>  
  
int main() {  
    std::vector<int> numbers = {1, 2, 3, 4, 5};  
    std::vector<int> squares(numbers.size());  
  
    // 使用lambda表达式来计算每个元素的平方，并将结果存储在squares中  
    std::transform(numbers.begin(), numbers.end(), squares.begin(), [](int num) {  
        return num * num;  
    });  
  
    // 打印squares容器中的元素  
    for (int num : squares) {  
        std::cout << num << " ";  
    }  
  
    std::cout << std::endl;  
  
    return 0;  
}

3、lambda表达式与闭包

闭包是一个能够记住并访问其自己的词法环境（lexical environment，即定义它的作用域）的函数或引用。在C++中，lambda表达式隐式地捕获其词法环境，从而创建闭包。

int x = 10;  
auto lambda = [x]() { std::cout << x << std::endl; }; // 捕获x的值  
lambda(); // 输出10

在这个例子中，lambda 是一个闭包，因为它记住了 x 的值，即使它在 lambda 定义的作用域之外。

4、lambda表达式在并发编程中的作用

在C++中，lambda表达式经常与线程和异步操作结合使用，因为它们提供了一种简洁的方式来定义要在线程中执行的代码。

在这个例子中，我们使用lambda表达式定义了一个简单的线程任务，并将其传递给 std::thread 构造函数。

#include <iostream>  
#include <thread>  
  
void createThreadWithLambda() {  
    std::thread t([]() {  
        std::cout << "Hello from thread!\n";  
    });  
    t.join();  
}  
  
int main() {  
    createThreadWithLambda(); // 输出 "Hello from thread!"  
    return 0;  
}

三、深入研究

1、Lambda表达式的性能

Lambda表达式中提供了一种简洁的函数式编程方式。然而，与普通的函数或方法相比，它们可能会有一些性能上的考虑。

间接调用：Lambda表达式通常会转化为函数对象或委托，这可能导致比直接函数调用更多的间接性，从而引入一些性能开销。
小对象优化：编译器可能会对小的、无捕获的lambda进行优化，以消除这种间接性。例如，在C++中，这样的lambda可能会内联到调用点。
捕获列表：如果lambda捕获了外部变量，那么它可能需要存储这些变量的副本或引用，这可能会增加内存使用或引入额外的内存访问。

2、在性能敏感的代码中使用lambda表达式的潜在影响和优化策略

避免不必要的捕获：只捕获确实需要的变量，并考虑使用引用捕获（如果可能）以减少拷贝。
内联：在C++中，如果可能，尝试将小的、无捕获的lambda内联到调用点。
避免在循环中创建新的lambda：在循环的每次迭代中创建新的lambda可能会导致不必要的内存分配和开销。
使用标准库算法：标准库算法通常已经针对性能进行了优化，因此，如果可以使用标准库算法代替手动循环和lambda，则可能会获得更好的性能。

3、Lambda表达式的限制和陷阱

生命周期问题：如果lambda捕获了外部变量的引用，并且该lambda的生命周期超过了外部变量的生命周期，那么可能会导致悬挂引用
不可变状态：默认情况下，通过值捕获的变量在lambda内部是不可变的。如果需要修改它们，必须使用mutable关键字。
捕获列表的意外行为：捕获列表的语法和行为可能会因编程语言而异，因此需要仔细阅读文档以确保正确使用。

4、何避免在lambda表达式中造成不必要的拷贝

引用捕获：对于大型对象或不需要拷贝的对象，使用引用捕获（&）而不是值捕获（=）。
移动捕获（C++特有）：在C++14及更高版本中，可以使用移动捕获（[var = std::move(var)]）来避免不必要的拷贝。
使用标准库容器：如果lambda需要处理多个元素，考虑使用标准库容器（如std::vector、std::array等），这些容器通常已经针对性能和内存使用进行了优化。
避免在lambda中创建大型对象：如果可能，尽量在lambda外部创建大型对象，并通过引用或指针将其传递给lambda。