C++ Lambda表达式详解：从入门到精通

Jay_515

于 2025-06-27 09:18:21 发布

阅读量273

点赞数 1

CC 4.0 BY-SA版权

文章标签： c++ Lambda

本文链接：https://blog.csdn.net/Jay_515/article/details/148944679

Lambda表达式是C11引入的最重要特性之一，它彻底改变了我们在C中编写函数对象的方式。本文将带你全面掌握Lambda表达式的使用技巧！

1. 什么是Lambda表达式？

Lambda表达式是C++11引入的一种匿名函数对象，它允许我们在需要函数的地方内联定义函数，无需单独命名。Lambda的出现极大简化了代码，特别是在使用STL算法时。

为什么需要Lambda？

简化代码：避免为简单操作单独编写函数对象
提高可读性：将逻辑保持在调用点附近
捕获上下文：直接使用当前作用域的变量

2. Lambda表达式基本语法

Lambda表达式的基本结构如下：

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

最简单的Lambda示例

// 定义一个Lambda并立即调用


[ ]() {


    std::cout << "Hello, Lambda!" << std::endl;
}();  // 注意最后的()表示立即调用

// 将Lambda赋值给变量

auto greet = [ ]() {

    std::cout << "Hello, Lambda!" << std::endl;
};
greet();  // 调用Lambda

3. 捕获列表详解（Capture List）

捕获列表决定了Lambda如何访问外部变量，这是Lambda最强大的特性之一。

3.1 值捕获 (Capture by Value)

int x = 10, y = 20;

// 值捕获：创建外部变量的副本
auto add = [x, y]() {
    std::cout << "Sum: " << x + y << std::endl;
};
add();  // 输出: Sum: 30

x = 100;  // 修改原始x
add();    // 仍然输出: Sum: 30 (使用捕获时的副本)

3.2 引用捕获 (Capture by Reference)

int counter = 0;

// 引用捕获：直接操作外部变量
auto increment = [&counter]() {
    counter++;
};

increment();
increment();
std::cout << "Counter: " << counter << std::endl; // 输出: Counter: 2

3.3 隐式捕获

int a = 5, b = 10;

// 隐式值捕获所有外部变量
auto sum_all = [=]() {
    return a + b;
};

// 隐式引用捕获所有外部变量
auto double_all = [&]() {
    a *= 2;
    b *= 2;
};

// 混合捕获：值捕获a，引用捕获其他
auto mixed = [=, &b]() {
    b = a + b;  // a是副本，b是引用
};

3.4 捕获时的初始化（C++14）

int x = 10;

// 在捕获列表中初始化新变量
auto lambda = [value = x + 5]() {
    return value;
};

std::cout << lambda(); // 输出: 15

4. mutable关键字

默认情况下，值捕获的变量在Lambda内是const的。使用mutable可以修改这些副本：

int count = 0;

auto counter = [count]() mutable {
    count++;  // 修改副本
    return count;
};

std::cout << counter(); // 1
std::cout << counter(); // 2
std::cout << count;     // 0 (原始变量不变)

5. 指定返回类型

当Lambda体包含多个返回语句时，需要显式指定返回类型：

// 自动推断返回类型

auto square = [ ](int x) { return x * x; };


// 显式指定返回类型

auto divide = [ ](double a, double b) -> double {

    if (b == 0) return 0;
    return a / b;
};

std::vector<int> nums = {-5, 2, -3, 4};
// 转换负数为正数
std::transform(nums.begin(), nums.end(), nums.begin(),


    [ ](int n) -> int {


        if (n < 0) return -n;
        return n;
    });

6. Lambda与STL算法

Lambda与STL算法完美配合，大幅提高代码可读性：

std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// 使用Lambda作为谓词
auto even_count = std::count_if(numbers.begin(), numbers.end(), 


    [ ](int n) { return n % 2 == 0; });


std::cout << "Even numbers: " << even_count << std::endl;

// 使用Lambda转换元素
std::vector<int> squares;
std::transform(numbers.begin(), numbers.end(), std::back_inserter(squares),


    [ ](int n) { return n * n; });



// 使用Lambda排序
std::sort(numbers.begin(), numbers.end(), 


    [ ](int a, int b) { return a > b; }); // 降序排序

7. 通用Lambda（C++14）

C++14允许在参数列表中使用auto，创建通用Lambda：

// 通用Lambda：可以处理任何支持+操作的类型

auto add = [ ](auto a, auto b) {

    return a + b;
};

std::cout << add(5, 3) << std::endl;      // 8 (整数)
std::cout << add(2.5, 3.7) << std::endl;  // 6.2 (浮点数)
std::cout << add(std::string("Hello "), 
                 std::string("World"));    // "Hello World" (字符串)

8. Lambda作为回调函数

Lambda非常适合作为回调函数：

#include <iostream>
#include <thread>
#include <future>

// 异步任务

auto future = std::async([ ]() {

    std::this_thread::sleep_for(std::chrono::seconds(1));
    return "Hello from async!";
});

std::cout << future.get() << std::endl;

// 定时器回调

auto timer = [ ](int count, auto callback) {

    for (int i = 0; i < count; ++i) {
        callback(i);
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
};


timer(5, [ ](int i) {

    std::cout << "Tick: " << i + 1 << std::endl;
});

9. Lambda的高级用法

9.1 递归Lambda

Lambda可以通过std::function实现递归：

#include <functional>

std::function<int(int)> factorial = [&factorial](int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
};

std::cout << factorial(5); // 输出: 120

9.2 高阶函数（返回Lambda的函数）

// 返回Lambda的函数

auto make_multiplier = [ ](int factor) {

    return [factor](int x) { return x * factor; };
};

auto triple = make_multiplier(3);
auto quintuple = make_multiplier(5);

std::cout << triple(10) << std::endl;    // 30
std::cout << quintuple(10) << std::endl;  // 50