QC++ / Qt 学习之路

Lambda 与可调用对象

掌握 lambda 全语法与四种可调用对象的取舍

进阶第 11 / 48 章第二篇 · C++ 进阶与工程实践

#从函数指针到可调用对象

在 Java 里想传递一段行为,你要写一个匿名内部类,或者依赖 Runnable、Function<T,R> 这类函数式接口;Python 的 lambda 好用但被限制成单行表达式,想写多行只能回头 def;JavaScript 的箭头函数最自由,随手就能捕获外层变量,代价是「到底捕获了什么」经常要靠猜。C++ 直到 C++11 才引入 lambda,但它的表达力比这三者都强——因为「捕获什么、按什么方式捕获、能否修改、返回什么类型」全部由你显式声明。这份精确性换来的是可控的生命周期和零开销的抽象,代价是需要你真正理解它。

先统一术语:可调用对象(Callable)指任何能写成 f(args) 的东西。C++ 里有四类:函数指针、函数对象(重载了 operator() 的类)、lambda 表达式产生的闭包、以及 std::function 包装器。它们能出现在同样的位置,但性能特征和适用场景差别巨大。理解这张表,是写好回调、异步任务和算法扩展点的前提。

#Lambda 语法全解

完整语法如下,其中只有捕获列表和函数体是必须的:

Text
[capture] (params) specifiers noexcept -> return_type requires { body }

日常写法通常是 [capture](params) { body }。编译器为每个 lambda 生成一个唯一的匿名闭包类型,捕获的变量变成这个类型的成员。这意味着两个写法完全相同的 lambda,类型也不相同——这是后面所有问题的根源。

#捕获列表的每一种写法

C++
#include <iostream>
#include <memory>
#include <string>

int main() {
    int a = 1;
    std::string name = "qt";

    // 1) 不捕获:只能用到参数和全局量
    auto no_cap = [](int x) { return x * 2; };

    // 2) 按值捕获指定变量
    auto by_value = [a](int x) { return a + x; };

    // 3) 按引用捕获指定变量
    auto by_ref = [&a](int x) { return a + x; };

    // 4) 混合捕获
    auto mixed = [a, &name] { return name + std::to_string(a); };

    // 5) C++14 初始化捕获:把 move-only 对象搬进闭包
    auto ptr = std::make_unique<int>(42);
    auto owner = [p = std::move(ptr)] { return *p; };

    // 6) C++17 按值捕获整个对象副本,避免 this 悬垂
    struct S { int v = 7; };
    S s;
    auto snap = [*this = s] { return this->v; }; // 取对象快照

    std::cout << no_cap(3) << " " << by_value(3) << " " << by_ref(3) << "\n"
              << mixed() << " " << owner() << " " << snap() << "\n";
}

[=] 和 [&] 是隐式捕获,写起来省事,但会把「这个 lambda 依赖哪些外部状态」藏起来;异步代码中一旦逃逸出作用域就是悬垂引用,因此现代风格推荐显式列出。C++20 起 [=] 隐式捕获 this 已被弃用,需要 this 请明写 [this] 或 [*this]。

与另外三门语言对比一下会更容易记住:JS 箭头函数捕获外层 let 天然是引用语义,闭包里的循环变量 bug 至今仍在困扰初学者;Python 闭包对不可变小对象是只读的,想修改必须 nonlocal 声明。C++ 反过来——默认按值且不可改,想改要 mutable,想引用要 &。C++ 把选择权交给你,同时把责任也交给你。

#mutable 与按值捕获的陷阱

按值捕获的变量在 lambda 体内默认是 const 的,因为生成的 operator() 带 const 限定。想修改副本,加 mutable:

C++
#include <iostream>

int main() {
    int counter = 0;

    auto tick = [counter]() mutable {
        return ++counter;   // 修改的是闭包内的副本
    };

    std::cout << tick() << tick() << tick() << "\n"; // 123
    std::cout << counter << "\n";                    // 仍是 0

    auto add = [counter](int x) mutable { counter += x; return counter; };
    std::cout << add(5) << add(5) << "\n";           // 5 10,状态被保留
}

注意 mutable lambda 即使捕获为空也能修改自己的状态,这让它成为轻量级的「有状态函数对象」。但请记住:闭包类型是不可复制赋值之外的普通类,按值捕获 mutable 的 lambda 传给算法时,每个副本都有独立状态——std::for_each 结束后你拿到的仍是旧值。

#返回类型推导与泛型 lambda

函数体只有一条 return 时,返回类型自动推导;存在多条返回路径且类型不一致时,必须显式声明:

C++
#include <iostream>
#include <typeinfo>

int main() {
    // 单一 return,推导出 int
    auto square = [](int x) { return x * x; };

    // 多分支类型不同,必须显式指定返回类型
    auto scale = [](int x, bool half) -> double {
        if (half) return x / 2.0;   // double
        return x;                   // int 会转成 double
    };

    // C++14 泛型 lambda:参数用 auto,等价于模板化的 operator()
    auto twice = [](auto x) { return x + x; };
    std::cout << twice(3) << " " << twice(3.5) << " " << twice(std::string("ab")) << "\n";

    // C++20 可以用概念约束模板参数
    auto only_int = [](std::integral auto x) { return x * 2; };
    std::cout << only_int(21) << "\n";
    // only_int(3.14); // 编译错误:double 不满足 std::integral
}

泛型 lambda 的 operator() 是成员函数模板,同一个 lambda 对象可以对不同类型实例化多次。这是它和普通函数模板最接近的地方,也是它无法被 std::function 无损存储的原因——std::function<int(int)> 只能固定一种调用签名。

#std::function:类型擦除的代价

每个 lambda 类型唯一,就没法把它们塞进同一个 vector。std::function<R(Args...)> 通过类型擦除把任意符合签名的可调用对象包装成统一类型。便利是真便利,代价也真实存在:

  1. 堆分配:大对象会动态分配内存(小对象可能走 SSO,但标准不保证);
  2. 间接调用:一次虚派发,编译器通常无法内联;
  3. 无法存储泛型 lambda 的全部实例。
C++
#include <functional>
#include <iostream>
#include <vector>

// 反例:用 std::function 接收,每次调用有间接开销
void apply_all_bad(const std::vector<int>& v, std::function<int(int)> f) {
    for (int x : v) std::cout << f(x) << " ";
}

// 正例:模板参数,调用可被完全内联,零开销
template <typename F>
void apply_all_good(const std::vector<int>& v, F&& f) {
    for (int x : v) std::cout << f(x) << " ";
}

// C++20:用 concept 给出可读的约束和清晰的报错
template <typename F>
requires std::invocable<F, int>
void apply_all_cxx20(const std::vector<int>& v, F&& f) {
    for (int x : v) std::cout << f(x) << " ";
}

int main() {
    std::vector<int> v{1, 2, 3};
    apply_all_bad(v, [](int x) { return x * 10; });
    apply_all_good(v, [](int x) { return x * 10; });
    apply_all_cxx20(v, [](int x) { return x * 10; });
}

经验法则:只在需要「存储」或「跨编译单元传递」时用 std::function(比如成员变量、容器、信号槽);函数参数位置上能用模板就用模板。C++20 之后用 concept 约束,既保留零开销,又能拿到人类可读的错误信息。

#std::bind、std::invoke 与函数对象

std::bind 在 C++11 时代用于参数绑定和重排,如今绝大多数场景被 lambda 取代——lambda 可读性更好、更易内联。剩下有用的场景是配合占位符做参数重排,但可读性依旧一般,新代码建议直接写 lambda。std::invoke(C++17)提供了统一的调用语法,能处理成员函数指针这种特殊情形,写泛型包装器时优先用它。

当回调需要携带状态时,显式的函数对象往往比 lambda 更清晰:

C++
#include <functional>
#include <iostream>
#include <vector>

// 有状态的函数对象:比捕获一堆变量的 lambda 更好测试
struct RunningAverage {
    double sum = 0.0;
    int count = 0;
    void operator()(double x) {
        sum += x;
        ++count;
    }
    double value() const { return count ? sum / count : 0.0; }
};

int main() {
    std::vector<double> data{1.0, 2.0, 3.0, 4.0};
    RunningAverage avg;
    for (double x : data) avg(x);           // 像函数一样调用
    std::cout << "avg = " << avg.value() << "\n";

    // std::invoke 统一调用:普通 lambda / 成员函数 / 函数对象都行
    auto f = [](int x) { return x + 1; };
    std::cout << std::invoke(f, 41) << "\n";
    std::cout << std::invoke(&RunningAverage::value, avg) << "\n";
}

#回调设计的三条实践准则

第一,同步回调用模板,异步存储用 std::function。前者在热路径上零开销,后者解决类型统一问题。第二,生命周期优先于语法。引用捕获的 lambda 被投递到线程池,而外部变量已销毁,是 C++ 并发代码最常见的崩溃来源;改用值捕获配合 shared_ptr,或在 Qt 中绑定 QObject 作为 context 对象。第三,避免在头文件的回调类型上暴露 lambda 细节,用 std::function 或概念约束做接口边界,内部实现再追求性能。

#小结

  • Lambda 生成唯一的闭包类型,捕获列表决定成员,默认 operator() 为 const,修改副本需要 mutable。
  • 优先显式捕获而非 [=]/[&];引用捕获遇上异步逃逸就是悬垂引用,这是头号陷阱。
  • 泛型 lambda(C++14 auto 参数)等价于模板化 operator(),C++20 可用概念约束参数类型。
  • std::function 带来类型擦除开销(可能堆分配 + 无法内联),热路径应改用模板参数或 concept。
  • std::bind 基本被 lambda 取代;泛型代码里用 std::invoke 统一调用形态;有状态回调用函数对象更可测。

#练习

  1. 写一个 Counter lambda:按值捕获计数变量并用 mutable 实现自增,验证外部变量不受影响;再改成引用捕获,观察输出差异并解释原因。
  2. 实现 template <typename F> auto retry(int times, F&& f):重复调用 f 直到返回 true 或次数耗尽,返回是否成功。要求 f 可以是普通函数、lambda 和函数对象三种形态。
  3. 用 std::function<void(int)> 存储三个不同签名实现的回调到 std::vector 中并依次调用;然后用模板版本改写,说明两种写法在可内联性上的差别。
  4. (进阶)捕获一个局部 std::string 的引用,把 lambda 投递到 std::thread 并 detach,制造悬垂引用;再用值捕获修复。用 AddressSanitizer 观察两种行为。
我的学习笔记笔记总览
笔记保存在本机浏览器(localStorage),换设备或清理缓存会丢失;重要内容请点「导出全部笔记」存成 .md 文件。