递归函数写成 lambda 的经典错误

递归和 lambda

为什么 auto Lambda 不能直接递归?

auto find = [&](int x) -> int {
    if (pre[x] == x) return x;
    return pre[x] = find(pre[x]); // 编译错误
};

上面代码会报编译错误:

Line 12: Char 30: error: '&' cannot precede a capture when the capture default is '&' 12 | auto find = [&, &find](int x) { | ~~~^~~~

这是因为在 Lambda 初始化期间,编译器还没有完成 find 的类型推导,所以不能在 Lambda 内直接调用 find。

你可以把它理解成:

auto find = 某个Lambda对象;

编译器需要先确定右侧 Lambda 表达式的类型,才能确定变量 find 的类型。

但是在右侧 Lambda 的函数体中,你又写了:

find(pre[x])

这就形成了一个问题:

  • 编译器正在推导 find 的类型。
  • Lambda 内部却已经尝试使用 find。
  • 此时 find 的类型尚未推导完成。

因此不能这样直接调用。

注意,这并不是 [&] 捕获范围不够,而是 find 的 auto 类型还未完成推导。

为什么普通函数可以递归?

例如:

int find(int x) {
    if (pre[x] == x) return x;
    return pre[x] = find(pre[x]);
}

普通函数的返回类型、参数类型在函数体编译之前就已经确定。

编译器知道 find 是一个函数,所以允许它调用自己。

但是:

auto find = ...;

需要通过初始化表达式推导类型,因此存在区别。

解决方法一:std::function

修改成 std::function 便编译通过。

function<int(int)> find = [&](int x) -> int {
    if (pre[x] == x) return x;
    return pre[x] = find(pre[x]);
};

关键在于:

function<int(int)> find

已经提前明确了 find 的类型。

其中:

  • 第一个 int:返回值类型。
  • 括号里的 int:参数类型。

即:

function<返回值类型(参数类型)> 变量名;

所以编译器在处理 Lambda 时,已经知道 find 是什么类型,可以在内部使用它。

此外,[&] 会按引用捕获外部的 find,从而实现递归。

优点: 写法简单,调用方式与普通函数一样。

缺点: std::function 存在一定的类型擦除开销,部分情况下还可能涉及动态内存分配。

解决方法二:auto&& self(泛型 Lambda 递归)

另一种方式不需要 std::function:

auto find = [&](auto&& self, int x) -> int {
    if (pre[x] == x) return x;
    return pre[x] = self(self, pre[x]); // 注意这里的写法
};

调用:

int fa = find(find, a); // 调用时需要传入自己
int fb = find(find, b);

1. 为什么要传入 self?

因为 Lambda 不能通过尚未完成推导的 find 直接调用自己。

但我们可以把 Lambda 对象作为参数传进去:

find(find, a);

其中:

  • 第一个 find:传入 Lambda 自身。
  • a:需要查找的节点。

进入函数后:

self(self, pre[x])

相当于再次调用这个 Lambda,并继续把它自己传进去。

2. 为什么是 auto&& self?

这里的 auto&& 是转发引用,可以接受传入的 Lambda 对象,并避免不必要的复制。

它的作用不是专门实现递归,而是让 Lambda 可以接收自身作为参数。

posted @ 2026-10-08 18:35  光風霽月  阅读(10)  评论(0)    收藏  举报