小记：DS给的一个lamda表达式例子

最近DeepSeek比较火，就用它来温习一下lambda表达式

问：帮我写一个C++的lambda表达式例子

DS: 当然！下面是一个简单的C++ lambda表达式的例子：

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

int main() {
    // 创建一个整数向量
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 使用lambda表达式打印每个元素
    std::for_each(numbers.begin(), numbers.end(), [](int n) {
        std::cout << n << " ";
    });

    std::cout << std::endl;

    // 使用lambda表达式计算元素的平方并存储到另一个向量中
    std::vector<int> squares;
    std::transform(numbers.begin(), numbers.end(), std::back_inserter(squares), [](int n) {
        return n * n;
    });

    // 打印平方后的结果
    std::for_each(squares.begin(), squares.end(), [](int n) {
        std::cout << n << " ";
    });

    std::cout << std::endl;

    return 0;
}

 

DS: 代码解释：

1. 第一个lambda表达式：

   [](int n) {
       std::cout << n << " ";
   }

   这个lambda表达式接受一个整数 n 作为参数，并打印它。它被传递给 std::for_each，用于遍历 numbers 向量并打印每个元素。

2. 第二个lambda表达式：

   [](int n) {
       return n * n;
   }

   这个lambda表达式接受一个整数 n 作为参数，并返回它的平方。它被传递给 std::transform，用于将 numbers 向量中的每个元素平方，并将结果存储到 squares 向量中。

    输出：

  1 2 3 4 5 
  1 4 9 16 25 

    这个例子展示了如何使用lambda表达式来简化代码，尤其是在需要传递简单函数对象的情况下。

 

问：有没有更复杂的lambda表达式例子

DS: 当然！下面是一个更复杂的C++ lambda表达式例子，展示了如何捕获外部变量、使用mutable关键字、以及返回一个lambda表达式。

 

#include <iostream>
#include <functional>

int main() {
    int x = 10;
    int y = 5;

    // 一个复杂的lambda表达式，捕获x和y，并返回一个lambda表达式
    auto complexLambda = [x, &y](int z) mutable -> std::function<int(int)> {
        // 修改捕获的x（因为是mutable）
        x += z;

        // 修改捕获的y（因为是引用）
        y += z;

        // 返回一个新的lambda表达式
        return [x, y](int w) mutable {
            return x + y + w;
        };
    };

    // 调用complexLambda，传入z = 3
    auto innerLambda = complexLambda(3);

    // 调用innerLambda，传入w = 2
    int result = innerLambda(2);

    // 输出结果
    std::cout << "Result: " << result << std::endl; // 输出: Result: 20
    std::cout << "x after complexLambda: " << x << std::endl; // 输出: x after complexLambda: 10
    std::cout << "y after complexLambda: " << y << std::endl; // 输出: y after complexLambda: 8

    return 0;
}

 

DS: 代码解析：

1. 捕获外部变量：

   • [x, &y]：x是按值捕获，y是按引用捕获。

   • 按值捕获的变量在lambda内部是只读的，除非使用mutable关键字。

   • 按引用捕获的变量可以直接修改。

2. mutable关键字：

   • 使用mutable后，按值捕获的变量（如x）可以在lambda内部修改。

   • 注意：这种修改不会影响外部的原始变量。

3. 返回一个lambda表达式：

   • complexLambda返回一个新的lambda表达式，这个新的lambda表达式捕获了x和y的值。

   • 返回的lambda表达式接受一个参数w，并返回x + y + w。

4. 调用过程：

   • complexLambda(3)：传入z = 3，修改x和y的值，并返回一个新的lambda表达式。

   • innerLambda(2)：调用返回的lambda表达式，传入w = 2，计算x + y + w。

5. 输出结果：

   • Result: 20：x（修改后为13） + y（修改后为8） + w（2） = 20。

   • 外部的x仍然是10，因为它是按值捕获的。

   • 外部的y被修改为8，因为它是按引用捕获的。

    更复杂的场景：

        如果你想要更复杂的lambda表达式，可以结合以下特性：

• 泛型lambda（C++14及以上）：

  auto genericLambda = [](auto a, auto b) {
      return a + b;
  };
  std::cout << genericLambda(3, 4.5) << std::endl; // 输出: 7.5

• 递归lambda：
  使用std::function来实现递归调用：

  std::function<int(int)> factorial = [&factorial](int n) -> int {
      return (n <= 1) ? 1 : n * factorial(n - 1);
  };
  std::cout << factorial(5) << std::endl; // 输出: 12