第一轮：基础认识

1.1 Lambda表达式的定义

问题: 请简要描述一下C++中的Lambda表达式是什么，以及其基本语法结构。

答案: Lambda表达式是C++11中引入的一种匿名函数特性，允许我们在代码中定义匿名的函数对象。Lambda表达式的基本语法结构如下：

[capture](parameters) -> return_type {
  // function body
}

capture: 捕获列表，定义了在Lambda表达式外部定义的变量在Lambda内部的可见性和使用方式。
parameters: 参数列表，和普通函数的参数列表一样。
return_type: 返回类型，可以省略，编译器会自动推导。
function body: 函数体，包含Lambda表达式的代码逻辑。

1.2 Lambda表达式的捕获方式

问题: C++中的Lambda表达式支持几种捕获方式？请举例说明。

答案: C++中的Lambda表达式支持以下几种捕获方式：

值捕获: 通过值捕获外部变量，捕获时会对变量进行拷贝。
```
int x = 10;
auto lambda = [x] { return x; };
```

引用捕获: 通过引用捕获外部变量。

int x = 10;
auto lambda = [&x] { return x; };

隐式值捕获: 捕获所有外部变量（以值的方式）。
```
int x = 10;
auto lambda = [=] { return x; };
```
隐式引用捕获: 捕获所有外部变量（以引用的方式）。
```
int x = 10;
auto lambda = [&] { return x; };
```

混合捕获: 同时使用值捕获和引用捕获。

int x = 10, y = 20;
auto lambda = [x, &y] { return x + y; };

无捕获: 不捕获任何外部变量。
```
auto lambda = [] { return 42; };
```

1.3 Lambda表达式的使用场景

问题: 你能描述一下Lambda表达式在实际编程中的一些应用场景吗？

答案: Lambda表达式在实际编程中非常有用，常见的应用场景包括：

作为参数传递: 可以将Lambda表达式作为参数传递给函数，特别是在需要回调函数的场景中。
在算法中使用: STL算法如sort, find_if等常常配合Lambda表达式使用。
延迟执行: Lambda表达式可以用来创建延迟执行的代码块。
替代小函数: 对于一些非常小的函数，使用Lambda表达式可以减少代码量，使代码更加紧凑。
作为局部函数使用: 在函数内部定义Lambda表达式，实现局部函数的功能。

第二轮：高级应用

2.1 Lambda表达式和标准库算法

问题: 如何使用Lambda表达式结合STL算法进行容器元素的过滤和转换？

答案: Lambda表达式可以与STL算法一起使用，以提供简洁而强大的操作。例如，我们可以使用std::transform和std::copy_if算法来进行元素的转换和过滤。

示例1: 元素转换

使用std::transform将容器中的每个元素都加1。

std::vector<int> nums = {1, 2, 3, 4, 5};
std::transform(nums.begin(), nums.end(), nums.begin(), [](int n) { return n + 1; });
// nums 现在是 {2, 3, 4, 5, 6}

示例2: 元素过滤

使用std::copy_if从一个容器复制满足条件的元素到另一个容器。

std::vector<int> nums = {1, 2, 3, 4, 5};
std::vector<int> even_nums;
std::copy_if(nums.begin(), nums.end(), std::back_inserter(even_nums), [](int n) { return n % 2 == 0; });
// even_nums 现在是 {2, 4}

2.2 Lambda表达式的存储和调用

问题: 如何存储Lambda表达式，并在需要的时候调用它？

答案: Lambda表达式的类型是编译器生成的，但我们可以使用std::function来存储任何可调用对象。下面是一个例子：

#include <functional>
#include <iostream>

int main() {
    std::function<int(int, int)> add = [](int a, int b) { return a + b; };
    int result = add(3, 4);
    std::cout << "Result: " << result << std::endl;  // 输出: Result: 7
    return 0;
}

在这个例子中，我们创建了一个可以存储接受两个int参数并返回int的Lambda表达式的std::function对象。然后我们调用这个Lambda表达式并打印结果。

2.3 Lambda表达式的返回类型推导

问题: Lambda表达式是如何推导其返回类型的？在什么情况下需要显式指定返回类型？

答案: 如果Lambda表达式的函数体只包含一个单一的return语句，或者是构造返回值的表达式，编译器就能够推导出返回类型。例如：

auto lambda = [](int a, int b) { return a + b; }; // 返回类型是 int

如果Lambda表达式的函数体包含多个return语句，而这些return语句返回不同类型的值，或者函数体不包含return语句但你想要它返回一个特定类型，你就需要显式地指定返回类型。你可以使用->操作符来指定返回类型：

auto lambda = [](int a, int b) -> double {
    if (b != 0) return a / b; // 这里返回一个double
    else return 0.0;
};

在这个例子中，即使a和b都是int，我们仍然可以通过显式指定返回类型来让Lambda表达式返回double。

第三轮：Lambda表达式的捕获细节

3.1 值捕获的行为

问题: 当使用值捕获时，Lambda表达式内部的变量是如何与外部变量相关联的？

答案: 当使用值捕获时，Lambda表达式在创建时会拷贝所捕获变量的当前值到内部。这意味着后续对外部变量的修改不会影响Lambda表达式内部的拷贝。

int x = 10;
auto lambda = [x] { return x; };
x = 20;
std::cout << lambda();  // 输出 10, 而不是 20

在这个例子中，即使我们在创建Lambda表达式后修改了x的值，Lambda表达式内部的拷贝仍然保持为创建时的值10。

3.2 引用捕获的行为

问题: 引用捕获和值捕获有什么不同？它又是如何工作的？

答案: 引用捕获会创建一个指向外部变量的引用，而不是拷贝它的值。这意味着对Lambda表达式内部变量的修改将影响外部变量，反之亦然。

int x = 10;
auto lambda = [&x] { return x; };
x = 20;
std::cout << lambda();  // 输出 20

在这个例子中，lambda通过引用捕获了x。当我们修改x的值后，通过lambda返回的值也发生了变化。

3.3 捕获成员变量

问题: 如何在Lambda表达式中捕获类的成员变量？

答案: 不能直接捕获成员变量。但是，可以捕获this指针来访问成员变量。

class MyClass {
public:
    int x = 10;

    void myFunction() {
        auto lambda = [this] { return x; };
        std::cout << lambda();  // 输出 10
    }
};

在这个例子中，lambda通过捕获this指针间接捕获了成员变量x。

3.4 捕获移动只类型

问题: 如何在Lambda表达式中捕获移动只类型的对象？

答案: 可以使用std::move来捕获移动只类型的对象。

std::unique_ptr<int> ptr = std::make_unique<int>(10);
auto lambda = [p = std::move(ptr)] { return *p; };

在这个例子中，我们通过初始化捕获(move capture)来捕获ptr。这将调用std::unique_ptr<int>的移动构造函数，将所有权从ptr转移到lambda内部的p。

第四轮：Lambda表达式的性能考虑

4.1 Lambda表达式的性能开销

问题: 使用Lambda表达式是否会引入额外的运行时开销？

答案: Lambda表达式本身通常不会引入额外的运行时开销。它们通常被编译器内联，这意味着使用Lambda表达式的性能与直接调用等价的普通函数或函数对象是相同的。然而，如果Lambda表达式很复杂，或者如果使用了捕获，那么性能的情况可能会有所不同。

4.1.1 内联和编译器优化

大多数现代编译器能够优化Lambda表达式，使其性能与等效的手写代码相同。

4.1.2 捕获的开销

捕获变量（特别是以值的方式捕获）可能会引入额外的拷贝或移动构造操作，这可能会对性能产生影响。尽量使用引用捕获或隐式捕获以减少开销。

4.2 Lambda表达式与std::function

问题: 在性能敏感的代码中，将Lambda表达式存储到std::function中是否有性能上的考虑？

答案: std::function是一个通用的可调用对象包装器，它有一定的性能开销。在性能敏感的代码中，直接使用Lambda表达式通常比将其存储到std::function中更高效，因为std::function的调用开销比直接调用Lambda表达式要大。

如果确实需要存储Lambda表达式或其他可调用对象，并且对性能有严格要求，可以考虑使用其他方法，如模板，或者直接使用函数指针（对于不捕获任何变量的Lambda表达式）。

4.3 选择正确的捕获策略

问题: 在编写Lambda表达式时，如何选择正确的捕获策略以优化性能？

答案: 选择正确的捕获策略可以优化Lambda表达式的性能：

值捕获: 当需要捕获的变量小且廉价复制时，值捕获是一个好选择。
引用捕获: 当需要捕获的变量大或者复制代价高时，或者需要修改捕获的变量时，应该使用引用捕获。
隐式捕获: 当需要捕获多个变量时，隐式捕获可以使代码更简洁。但要小心不要无意中捕获不需要的变量。
初始化捕获: 对于需要以移动语义捕获变量的情况，初始化捕获是一个很好的选择。

第五轮：Lambda表达式的高级主题

5.1 Lambda表达式的类型

问题: Lambda表达式的类型是什么？如何获取Lambda表达式的类型？

答案: Lambda表达式的类型是一个由编译器生成的唯一的、未命名的函数对象类型。因此，你不能直接声明一个Lambda表达式的类型。但是，你可以使用auto关键字来存储Lambda表达式：

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

如果你需要将Lambda表达式作为参数传递或者从函数返回Lambda表达式，你可以使用std::function来存储它，或者使用模板。

5.2 Lambda表达式和模板

问题: 如何在模板中使用Lambda表达式？

答案: 你可以在模板中使用Lambda表达式，就像使用普通函数一样。Lambda表达式可以用来实现策略模式、自定义排序等。

template <typename Func>
void runFunc(Func f) {
    f();
}

int main() {
    runFunc([] { std::cout << "Hello, World!" << std::endl; });
    return 0;
}

在这个例子中，runFunc是一个模板函数，接受一个可调用对象f作为参数，并执行它。我们传递了一个Lambda表达式到runFunc。

5.3 Lambda表达式的递归

问题: 如何使用Lambda表达式实现递归函数？

答案: 由于Lambda表达式的类型在声明时是未知的，我们不能直接在Lambda表达式内部调用它自己。但是，我们可以通过捕获一个指向自身的std::function来实现递归。

#include <functional>

int main() {
    std::function<int(int)> factorial = [&factorial](int n) -> int {
        return (n <= 1) ? 1 : n * factorial(n - 1);
    };
    
    std::cout << "Factorial of 5 is " << factorial(5) << std::endl; // 输出 120
    return 0;
}

在这个例子中，factorial是一个计算阶乘的Lambda表达式，它通过引用捕获自身来实现递归。

5.4 Lambda表达式的可调用性

问题: 什么情况下Lambda表达式是不可调用的？

答案: 一般来说，Lambda表达式总是可调用的。然而，如果Lambda表达式捕获了一个已经销毁或者超出作用域的变量，尝试调用它将导致未定义行为。此外，如果Lambda表达式捕获了一个不再有效的引用或指针，调用它也会是不安全的。

【C/C++ 软件开发模拟面试 集】C++ Lambda 表达式 相关知识点模拟面试