25. Lambda 与概念（Concepts）：C++20 约束 Lambda 参数类型

说实话，C++20 的概念（Concepts）是我这几年最期待的特性之一。以前写模板，编译报错那叫一个酸爽——几百行的错误信息，最后发现只是传了个不支持 ++ 的类型。有了 Concepts，我们终于能在编译期给类型加上「安检门」了。

那 Lambda 呢？Lambda 本质上就是个匿名函数对象，它当然也能享受 Concepts 带来的好处。今天我们就聊聊怎么用 Concepts 约束 Lambda 的参数类型。

为什么需要约束 Lambda 参数？

先看个例子。假设你写了个 Lambda，想对参数做加法：

auto add = [](auto a, auto b) { return a + b; };

这段代码看着挺美，对吧？但如果你传两个 std::string 进去，它确实能拼串；传两个 int 也能加。可万一传了个 std::vector 和一个 int 呢？编译报错是小事，关键是报错信息可能让你怀疑人生。

我在项目中遇到过类似情况。有一次团队里有人写了个通用 Lambda，用来处理数值计算。结果同事不小心传了个 std::string 进去，编译过了（因为字符串也能 +），但运行时逻辑完全错了。嗯，从那以后我就养成了给 Lambda 参数加约束的习惯。

C++20 概念基础

概念说白了就是一组编译期布尔条件。你可以把它理解成「类型必须满足的契约」。C++20 标准库已经提供了一些常用概念，比如：

概念 含义
std::integral 整数类型（int, char, long 等）
std::floating_point 浮点类型（float, double）
std::same_as<T> 类型完全等于 T
std::convertible_to<T> 可以隐式转换为 T
std::invocable<F, Args...> 可调用对象，能接受 Args 参数

在 Lambda 中使用 Concepts

语法其实很简单。你只需要在 auto 前面加上概念名就行：

auto add = [](std::integral auto a, std::integral auto b) {
    return a + b;
};

这样写，add 就只接受整数类型了。传个 double 进去？编译直接报错，而且错误信息清晰多了——「类型不满足 integral 概念」。

我个人习惯把这种写法叫做「带安检的泛型 Lambda」。你想想看，以前写模板你得靠 SFINAE 或者 static_assert 来约束，那代码又长又丑。现在一行概念就搞定。

多参数约束

有时候你需要约束多个参数之间的关系。比如写个比较函数，要求两个参数类型相同：

auto compare = [](std::same_as auto a, std::same_as auto b) {
    return a == b;
};

注意：这里 std::same_as auto 的意思是「每个参数都必须是同一个类型」。如果你传 compare(1, 2.0)，编译器会告诉你 int 和 double 不满足 same_as。

还有一种常见场景：要求参数支持某种操作。比如我想写个 Lambda，只接受能 ++ 的类型：

auto increment = [](std::incrementable auto x) {
    return ++x;
};

std::incrementable 是 C++20 标准库提供的概念，它要求类型支持前置 ++ 且返回引用。嗯，这里要注意：std::incrementable 比单纯检查 operator++ 更严格，它还要求类型是可移动的。

自定义概念

标准库的概念够用吗？说实话，很多时候不够。比如你写了个数学库，需要约束「支持加减乘除的数值类型」。这时候就得自己定义概念了：

template <typename T>
concept Arithmetic = std::integral<T> || std::floating_point<T>;

auto compute = [](Arithmetic auto a, Arithmetic auto b) {
    return (a + b) * (a - b);
};

你看，概念可以用逻辑运算符组合。你甚至可以在概念里写更复杂的约束：

template <typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::convertible_to<T>;
};

这个 Addable 概念要求：a + b 合法，且结果能隐式转换为 T。这就是 requires 表达式的威力——你可以在概念里写「伪代码」来描述类型必须支持的操作。

我在项目中就经常用这种自定义概念。有一次写一个图像处理库，需要约束像素类型必须支持加减和标量乘法。用 requires 表达式写了个 PixelArithmetic 概念，后面所有 Lambda 都加上这个约束。后来新同事加了个不支持乘法的像素类型，编译直接报错，根本跑不到运行时。

概念与 auto 的微妙区别

你可能会问：std::integral auto x 和 auto x 到底差在哪？

说白了，auto 是「什么类型都行」，而 std::integral auto 是「必须是整数类型」。前者是自由放任，后者是加了门禁。

但有个细节要注意：概念约束是在模板实例化时检查的，而不是在定义时。所以：

auto bad = [](std::integral auto x) {
    return x + 1.0;  // 编译通过，因为 x 是整数，1.0 是 double
};

这段代码能编译。因为概念只约束了参数类型，没约束函数体。如果你传个 int 进去，x + 1.0 结果是 double，没问题。但如果你传个 char 进去，x + 1.0 也是 double，也没问题。概念只管「进门」，不管「进门后做什么」。

避坑指南

我曾经踩过一个坑：概念和 decltype 一起用的时候，容易搞混。比如：

auto lambda = [](auto x) {
    // 错误写法
    // std::integral auto y = x;
    
    // 正确写法
    std::integral auto y = x;  // 这其实不对！
};

等等，上面这个例子其实有歧义。在 C++20 中，std::integral auto y = x; 是合法的——它声明了一个变量 y，类型由 x 推导，但要求推导出的类型满足 std::integral。所以如果 x 是 double，这行会编译报错。

但如果你是想在 Lambda 参数里用概念，那语法是：

auto lambda = [](std::integral auto x) { ... };

注意位置：概念在 auto 前面，而不是后面。这个顺序我一开始也老写反。

概念与泛型 Lambda 的完美结合

最后，我们画一张图来总结一下 Lambda 与 Concepts 的关系：

Lambda 与 Concepts 知识体系 Lambda 表达式 Concepts 约束 标准概念 integral / floating_point 自定义概念 requires 表达式 组合约束 逻辑运算符 || && 编译期类型安全 + 清晰错误信息 + 代码自文档化

从这张图能看出来，Concepts 给 Lambda 带来了三层好处：

  • 编译期类型安全：错误在编译时就被捕获，不会拖到运行时
  • 清晰错误信息：不再有几百行的模板报错，直接告诉你哪个概念没满足
  • 代码自文档化：看到 std::integral auto x，你就知道 x 必须是整数
小技巧：如果你在写库代码，建议把概念约束写在 Lambda 参数上。这样用户传错类型时，报错信息会直接指向你的 Lambda，而不是内部实现。我在公司内部库就是这么做的，同事反馈说「终于能看懂编译错误了」。
注意：概念约束会增加编译时间，因为编译器需要做额外的类型检查。不过这点开销通常可以忽略。另外，概念不是运行时检查——它只在编译期生效，不会影响运行性能。

好了，关于 Lambda 与 Concepts 的内容就聊到这。记住一句话：概念是给类型加的「安检门」，Lambda 是「匿名函数对象」。两者结合，让你的泛型代码既灵活又安全。

公众号:蓝海资料掘金营，微信deep3321

← 上一章 📖 返回目录 下一章 →