迹忆客 专注技术分享

在本文中，我们将了解 C++ 中可用的递归 lambda。

C++ 递归 Lambda 函数

递归是指函数（直接或间接）调用自身的过程，这个过程对应的函数称为递归函数。 递归 lambda 表达式是此过程的结果。

当使用递归方法解决某些问题时，解决起来要简单得多。

在重构本地代码的过程中，lambda 是一个有用的工具。 另一方面，在某些情况下我们希望从内部使用 lambda。

这样做可能出于以下两个原因之一：启用直接递归或使闭包可以注册为延续。 当前版本的 C++ 使得这项任务很难成功完成。

C++ 递归 Lambda 函数的实现

第一步，我们将导入必要的库。

#include <functional>
#include <iostream>

在 main() 函数中，初始化一个 int 类型的变量并为其分配一个整数值。

int main()
{
    int anyNumber = 456789;
}

然后，创建一个类型为 void 的函数，并将其命名为verseByRecursiveLambda。

function<void()> reverseByRecursiveLambda;

现在，使用递归 lambda 函数初始化reverseByRecursiveLambda 函数。

reverseByRecursiveLambda = [&]() {};

在此方法中，您应该实现一个检查，表明如果 anyNumber 的整数值等于 0，则不应返回任何内容。 如果不是这种情况，该函数应继续执行下一组操作。

然后，该函数将执行一系列数学计算，然后打印结果。 最后一步，它将再次运行名为reverseByRecursiveLambda()的函数。

if (anyNumber == 0)
  return;

cout << anyNumber % 10 << " ";
anyNumber /= 10;
reverseByRecursiveLambda();

该函数完成执行后，唯一需要做的就是在 main() 方法中调用该函数。

int main()
{
    reverseByRecursiveLambda();
}

完整源代码：

#include <functional>
#include <iostream>

using namespace std;

int main()
{
    int anyNumber = 123456789;

    function<void()> reverseByRecursiveLambda;

    reverseByRecursiveLambda = [&]() {
        if (anyNumber == 0)
            return;

        cout << anyNumber % 10 << " ";
        anyNumber /= 10;
        reverseByRecursiveLambda();
    };

    reverseByRecursiveLambda();
}

输出:

9 8 7 6 5 4 3 2 1

使用 std::function 的 C++ 递归 Lambda 函数

std::function 类模板是一个多态函数包装器，可用于各种目的。 任何 lambda 表达式绑定表达式或其他函数对象都可以在 std::function 类的实例内存储、复制和调用。

此外，这些实例可以保存指向成员函数的指针和指向数据成员的指针。

在下面的示例中，我们需要拍摄阶乘的快照，然后我们可以在 lambda 体内引用它。

示例代码：

#include <functional>
#include<iostream>

int main() {

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

    std::cout << "The factorial of 5 is: " << factorial(5);
    return factorial(5);
}

输出:

The factorial of 5 is: 120

使用通用 Lambda 的 C++ 递归 Lambda 函数

泛型 Lambda 表达式是指至少具有一个 auto 类型参数的 lambda 表达式。

创建递归 lambda 函数不需要使用 std::function ，这要归功于通用 lambda 表达式，这使得此选项成为可能。 lambda 表达式的类型不能仅通过其名称来确定。

因此，在 C++14 发布之前，需要将递归 lambda 表达式包含在 std::function 内。 它不依赖于 std::function，并且不需要捕获任何数据即可在任何数字基本类型上正确执行。

在示例中，我们将演示如何使用通用 lambda auto 显示存储在映射中的数据。

示例代码：

#include <algorithm>
#include <iostream>
#include <map>
#include <string>

int main() {
    const std::map<std::string, int> numbers {
        { "Saad", 22 }, {"Zaryab", 23 }, {"Zeeshan", 24 }
    };

    std::for_each(std::begin(numbers), std::end(numbers),
        [](const auto& entry) {
            std::cout << "Name: " << entry.first << "   Age: " << entry.second << '\n';
        }
    );
}

GCC 11.1.0 是本演示中使用的编译器的名称。

输出：

Name: Saad   Age: 22
Name: Zaryab   Age: 23
Name: Zeeshan   Age: 24

使用 y_combinator 的 C++ 递归 Lambda 函数

由于匿名函数（也称为 lambda）仅在逻辑简单且应提取到命名函数时使用，因此不可能在 lambda 内进行递归调用。

然而，让我们想象一下，我们不能使用递归。 只要函数在我们的语言中被视为一等公民（它们可以分配给变量，作为参数提供，并像任何其他对象一样返回），我们仍然可以编写递归实现。

Y 组合器是用于此目的的一个有用的高阶函数。 尽管它的名字听起来不祥，但它只是一个高阶函数，一个包装另一个函数的函数。

以下是使用 y 组合器创建递归 lambda 函数来列出斐波那契数列的示例。

示例代码：

#include <iostream>

template<typename Function>
struct YCombinator
{
    Function yFunction;

    template<typename... Args>
    decltype(auto) operator()(Args&&... args)
    {
        return yFunction(*this, std::forward<Args>(args)...);
    }
};

template<typename Function>
decltype(auto) make_YCombinator(Function f) {
    return YCombinator<Function> { f };
}

int main()
{
    auto fib = make_YCombinator([](auto self, int n) {
        if (n < 2)
            return 1;
        return self(n - 1) + self(n - 2);
    });

    for (int i = 0; i < 10 ; ++i)
        std::cout << "fib(" << i << ") = " << fib(i) << "\n";

    return 0;
}

GCC 11.1.0 是本演示中使用的编译器的名称。

输出：

fib(0) = 1
fib(1) = 1
fib(2) = 2
fib(3) = 3
fib(4) = 5
fib(5) = 8
fib(6) = 13
fib(7) = 21
fib(8) = 34
fib(9) = 55