Lambda 表达式

Lambda 表达式是现代 C++ 函数式编程风格的基石。它让你能够在需要的地方就地定义匿名函数对象,避免编写大量只使用一次的具名函数或函数对象类。从 C++11 引入以来,Lambda 在每个标准版本中都得到了增强,已成为日常 C++ 编程中最常用的特性之一。

Lambda 基础语法

Lambda 表达式的完整语法结构如下:

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

各部分的含义:

  • 捕获列表 [] — 指定 Lambda 如何访问外部作用域中的变量(必须存在,即使为空)
  • 参数列表 () — 与普通函数参数相同(无参数时可省略括号)
  • 返回类型 -> — 通常可省略,编译器自动推导
  • 函数体 {} — Lambda 执行的代码

从最简单到逐渐复杂的例子:

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // 最简形式:无捕获、无参数
    auto hello = [] { std::cout << "Hello Lambda!\n"; };
    hello();  // 输出: Hello Lambda!

    // 带参数
    auto add = [](int x, int y) { return x + y; };
    std::cout << add(3, 4) << "\n";  // 输出: 7

    // 显式返回类型(通常不需要,但有歧义时可用)
    auto divide = [](double a, double b) -> double {
        if (b == 0.0) return 0.0;  // 避免除零
        return a / b;
    };
    std::cout << divide(10.0, 3.0) << "\n";  // 输出: 3.33333

    // 直接作为算法参数(最常见用法)
    std::vector<int> nums{5, 2, 8, 1, 9, 3};
    std::sort(nums.begin(), nums.end(), [](int a, int b) {
        return a > b;  // 降序排列
    });
    // nums: {9, 8, 5, 3, 2, 1}
}

何时需要显式返回类型?当函数体有多个 return 语句且返回不同类型时,编译器可能无法推导,此时需要用 -> 显式指定。日常使用中,90% 以上的 Lambda 都可以省略返回类型。

捕获语义

捕获列表控制 Lambda 如何访问定义它的作用域中的局部变量。这是 Lambda 与普通函数最大的区别 — Lambda 可以形成闭包(closure)。

语法 含义 说明
[] 不捕获 Lambda 无法访问外部局部变量
[=] 按值捕获所有 复制所有被引用的外部变量
[&] 按引用捕获所有 引用所有被引用的外部变量
[x] 按值捕获 x 仅复制变量 x
[&x] 按引用捕获 x 仅引用变量 x
[=, &x] 混合捕获 默认按值,但 x 按引用
[&, x] 混合捕获 默认按引用,但 x 按值
[x = std::move(obj)] 初始化捕获 (C++14) 将 obj 移动到捕获变量 x 中
[this] 捕获 this 指针 访问当前对象的成员
[*this] 捕获 this 的副本 (C++17) 复制整个对象,安全但有开销

捕获方式的使用示例:

#include <iostream>
#include <vector>
#include <algorithm>
#include <memory>

int main() {
    int threshold = 10;
    std::string prefix = "Result: ";

    std::vector<int> data{3, 14, 15, 9, 26, 5, 35};

    // 按值捕获 threshold
    auto count = std::count_if(data.begin(), data.end(),
        [threshold](int x) { return x > threshold; });
    std::cout << "大于 " << threshold << " 的个数: " << count << "\n";

    // 按引用捕获 — 可以修改外部变量
    int sum = 0;
    std::for_each(data.begin(), data.end(), [&sum](int x) {
        sum += x;
    });
    std::cout << "总和: " << sum << "\n";

    // 混合捕获:prefix 按值,sum 按引用
    std::for_each(data.begin(), data.end(), [prefix, &sum](int x) {
        std::cout << prefix << x << "\n";
    });

    // 初始化捕获(C++14):移动不可复制的对象
    auto ptr = std::make_unique<int>(42);
    auto task = [p = std::move(ptr)]() {
        std::cout << "Value: " << *p << "\n";
    };
    // ptr 现在是 nullptr,所有权已转移到 lambda 中
    task();  // 输出: Value: 42
}

引用捕获的生命周期陷阱!如果 Lambda 的生存期超过了被引用变量的生存期,将导致悬垂引用(dangling reference)。典型场景:将捕获了局部变量引用的 Lambda 存储到容器中、返回给调用者、或传递给异步任务。此时应使用按值捕获或初始化捕获。

// 危险示例 — 不要这样做!
#include <functional>

std::function<int()> make_counter() {
    int count = 0;
    // 错误:返回后 count 已销毁,引用悬垂
    // return [&count]() { return ++count; };

    // 正确:按值捕获(配合 mutable,稍后讲解)
    return [count]() mutable { return ++count; };
}

// [this] vs [*this] 示例
struct Widget {
    int value = 10;

    auto get_printer() {
        // [this] 只捕获指针 — 如果 Widget 对象被销毁,this 悬垂
        // [*this] 复制整个对象 — 安全但有拷贝开销
        return [*this]() { std::cout << value << "\n"; };
    }
};

泛型 Lambda(auto 参数)

C++14 允许在 Lambda 参数中使用 auto,使其成为泛型的(类似函数模板)。C++20 更进一步,支持模板 Lambda 语法。

#include <iostream>
#include <vector>
#include <string>
#include <numeric>

int main() {
    // C++14 泛型 Lambda — 参数使用 auto
    auto print = [](const auto& x) {
        std::cout << x << "\n";
    };
    print(42);             // int
    print(3.14);           // double
    print("hello");        // const char*
    print(std::string{"world"});  // std::string

    // 泛型 Lambda 实现通用比较器
    auto less_by_size = [](const auto& a, const auto& b) {
        return a.size() < b.size();
    };
    std::vector<std::string> words{"lambda", "is", "powerful", "in", "cpp"};
    std::sort(words.begin(), words.end(), less_by_size);
    // words: {"is", "in", "cpp", "lambda", "powerful"}

    // C++20 模板 Lambda — 可以指定类型约束
    auto sum_vec = []<typename T>(const std::vector<T>& v) {
        return std::accumulate(v.begin(), v.end(), T{});
    };
    std::vector<int> ints{1, 2, 3, 4, 5};
    std::vector<double> dbls{1.1, 2.2, 3.3};
    std::cout << sum_vec(ints) << "\n";   // 15
    std::cout << sum_vec(dbls) << "\n";   // 6.6

    // C++20 模板 Lambda + Concepts 约束
    auto print_container = []<typename T>(const std::vector<T>& v)
        requires std::is_arithmetic_v<T>
    {
        for (const auto& elem : v) {
            std::cout << elem << " ";
        }
        std::cout << "\n";
    };
    print_container(ints);  // OK
    // print_container(words);  // 编译错误:string 不是 arithmetic 类型
}

auto vs 模板 Lambda:如何选择?如果只需要"接受任意类型",auto 参数足够简洁。当你需要在函数体中引用参数的类型(如创建同类型变量),或需要约束多个参数为同一类型时,使用 C++20 模板 Lambda 语法更清晰。

mutable Lambda

默认情况下,按值捕获的变量在 Lambda 内部是 const 的 — 你不能修改它们的副本。如果需要修改捕获的副本,必须加上 mutable 关键字。

#include <iostream>
#include <functional>

int main() {
    int counter = 0;

    // 编译错误:不能修改按值捕获的变量
    // auto inc = [counter]() { return ++counter; };

    // 正确:mutable 允许修改捕获的副本
    auto inc = [counter]() mutable { return ++counter; };

    std::cout << inc() << "\n";  // 1
    std::cout << inc() << "\n";  // 2
    std::cout << inc() << "\n";  // 3

    // 注意:外部的 counter 并未改变!
    std::cout << "外部 counter = " << counter << "\n";  // 0
}

// 实用案例:生成唯一 ID
auto make_id_generator(int start = 0) {
    return [id = start]() mutable { return id++; };
}

// 使用
void demo() {
    auto gen = make_id_generator(100);
    std::cout << gen() << "\n";  // 100
    std::cout << gen() << "\n";  // 101
    std::cout << gen() << "\n";  // 102
}

mutable 的本质:Lambda 在底层是一个匿名类,捕获的变量是其成员。默认情况下 operator() 是 const 成员函数,所以不能修改成员。mutable 将其改为非 const 成员函数。

立即调用(IIFE)

IIFE(Immediately Invoked Function Expression,立即调用函数表达式)是一种将 Lambda 定义后立即调用的模式。它主要用于复杂的 const 变量初始化。

#include <iostream>
#include <string>
#include <vector>

enum class LogLevel { Debug, Info, Warning, Error };

int main() {
    // 问题:复杂初始化逻辑无法直接用于 const 变量
    // const std::string msg = ???;  // 需要 if-else 逻辑

    LogLevel level = LogLevel::Warning;

    // IIFE 解决:Lambda 立即调用,返回值初始化 const 变量
    const std::string msg = [&]() -> std::string {
        switch (level) {
            case LogLevel::Debug:   return "[DEBUG]";
            case LogLevel::Info:    return "[INFO]";
            case LogLevel::Warning: return "[WARN]";
            case LogLevel::Error:   return "[ERROR]";
        }
        return "[UNKNOWN]";
    }();  // 注意末尾的 () — 立即调用!

    std::cout << msg << " Something happened\n";

    // 另一个场景:需要多步计算的 const 初始化
    const std::vector<int> fibonacci = [&]() {
        std::vector<int> fib{0, 1};
        for (int i = 2; i < 20; ++i) {
            fib.push_back(fib[i-1] + fib[i-2]);
        }
        return fib;
    }();
    // fibonacci 是 const 的,初始化后不能修改

    // IIFE 初始化互斥资源
    const auto config = [&]() {
        // 可以在这里做文件读取、解析、验证等复杂操作
        struct Config { int port; std::string host; };
        return Config{8080, "localhost"};
    }();
}

为什么用 IIFE?三个好处:(1) 保持变量 const,表达不变意图;(2) 限制临时变量的作用域,不污染外部命名空间;(3) 让初始化逻辑内聚,更易阅读和维护。

Lambda 与 std::function

每个 Lambda 表达式都有一个唯一的匿名类型(即使代码完全相同的两个 Lambda 类型也不同)。当需要存储、传递多种不同 Lambda 时,std::function 提供了类型擦除的容器。

#include <iostream>
#include <functional>
#include <vector>
#include <map>

int main() {
    // auto 保留 Lambda 的精确类型 — 零开销
    auto fast_add = [](int a, int b) { return a + b; };

    // std::function 擦除类型 — 有堆分配和间接调用开销
    std::function<int(int, int)> flexible_op = fast_add;
    flexible_op = [](int a, int b) { return a * b; };  // 可以重新赋值

    // 典型用途:存储回调函数的容器
    std::vector<std::function<void()>> callbacks;
    callbacks.push_back([] { std::cout << "Callback 1\n"; });
    callbacks.push_back([] { std::cout << "Callback 2\n"; });
    for (auto& cb : callbacks) cb();

    // 典型用途:命令模式 / 事件分发
    std::map<std::string, std::function<double(double, double)>> ops;
    ops["add"] = [](double a, double b) { return a + b; };
    ops["sub"] = [](double a, double b) { return a - b; };
    ops["mul"] = [](double a, double b) { return a * b; };
    ops["div"] = [](double a, double b) { return b != 0 ? a / b : 0; };

    std::cout << ops["add"](10, 3) << "\n";  // 13
    std::cout << ops["mul"](4, 5) << "\n";   // 20
}

std::function 的性能代价:它内部可能触发堆分配(小对象优化可能避免),并引入虚函数调用般的间接开销。规则很简单:局部使用 Lambda 时优先用 auto;只有当需要运行时多态(如存入容器、作为类成员)时才用 std::function。

// 函数参数:模板 vs std::function

// 推荐:模板参数 — 编译器可内联 Lambda,零开销
template<typename Func>
void apply_twice(int x, Func f) {
    std::cout << f(f(x)) << "\n";
}

// 不推荐(除非必要):std::function 参数 — 有间接调用开销
void apply_twice_slow(int x, std::function<int(int)> f) {
    std::cout << f(f(x)) << "\n";
}

void demo() {
    apply_twice(3, [](int n) { return n * 2; });       // 12,零开销
    apply_twice_slow(3, [](int n) { return n * 2; });  // 12,有开销
}

实际应用场景

场景一:作为算法回调

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

int main() {
    std::vector<int> scores{85, 92, 78, 95, 68, 88, 73, 91};

    // 统计及格人数
    auto pass_count = std::count_if(scores.begin(), scores.end(),
        [](int s) { return s >= 80; });
    std::cout << "及格人数: " << pass_count << "\n";

    // 找到最接近 90 分的成绩
    auto closest = *std::min_element(scores.begin(), scores.end(),
        [](int a, int b) {
            return std::abs(a - 90) < std::abs(b - 90);
        });
    std::cout << "最接近90的成绩: " << closest << "\n";

    // 将所有成绩加 5 分(不超过 100)
    std::transform(scores.begin(), scores.end(), scores.begin(),
        [](int s) { return std::min(s + 5, 100); });
}

场景二:自定义排序比较器

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <set>

struct Student {
    std::string name;
    int score;
    int age;
};

int main() {
    std::vector<Student> students{
        {"Alice", 92, 20},
        {"Bob", 85, 22},
        {"Carol", 92, 21},
        {"Dave", 78, 20}
    };

    // 多条件排序:先按分数降序,分数相同按年龄升序
    std::sort(students.begin(), students.end(),
        [](const Student& a, const Student& b) {
            if (a.score != b.score) return a.score > b.score;
            return a.age < b.age;
        });

    for (const auto& s : students) {
        std::cout << s.name << " " << s.score << " " << s.age << "\n";
    }

    // Lambda 作为 std::set 的比较器
    auto cmp = [](const std::string& a, const std::string& b) {
        return a.size() < b.size();  // 按长度排序
    };
    std::set<std::string, decltype(cmp)> words(cmp);
    words.insert("hello");
    words.insert("hi");
    words.insert("hey");
    // words 按字符串长度排列
}

场景三:事件处理与回调

#include <iostream>
#include <functional>
#include <vector>
#include <string>

// 简单事件系统
class EventBus {
public:
    using Handler = std::function<void(const std::string&)>;

    void subscribe(const std::string& event, Handler handler) {
        handlers_[event].push_back(std::move(handler));
    }

    void emit(const std::string& event, const std::string& data) {
        if (auto it = handlers_.find(event); it != handlers_.end()) {
            for (auto& handler : it->second) {
                handler(data);
            }
        }
    }

private:
    std::map<std::string, std::vector<Handler>> handlers_;
};

int main() {
    EventBus bus;

    // 使用 Lambda 注册事件处理器
    bus.subscribe("user_login", [](const std::string& user) {
        std::cout << "欢迎回来, " << user << "!\n";
    });

    bus.subscribe("user_login", [](const std::string& user) {
        std::cout << "记录登录日志: " << user << "\n";
    });

    int error_count = 0;
    bus.subscribe("error", [&error_count](const std::string& msg) {
        ++error_count;
        std::cout << "错误 #" << error_count << ": " << msg << "\n";
    });

    bus.emit("user_login", "Alice");
    bus.emit("error", "连接超时");
    bus.emit("error", "文件未找到");
}

本章小结

  • 基础语法:[captures](params) -> ret { body },返回类型通常可省略
  • 捕获语义:按值 [x] 安全但不能修改;按引用 [&x] 高效但注意生命周期;初始化捕获 [x = expr] 支持移动
  • 泛型 Lambda:C++14 用 auto 参数,C++20 用模板语法 []<typename T>
  • mutable:按值捕获默认 const,需修改副本时加 mutable
  • IIFE:[&]{ ... }() 用于复杂 const 初始化
  • std::function:需要类型擦除时使用,局部 Lambda 优先用 auto
  • 最佳实践:优先按值捕获,显式列出捕获变量(避免 [=] / [&] 隐式捕获)