C ++匿名函数:揭开C++ Lambda表达式的神秘面纱_匿名函数作为形参 c++

---

引言：Lambda表达式的魅力 (The Charm of C++ Lambda Expressions)

在编程世界里，每一门编程语言都有自己的独特之处。C++，作为一门混合了过程式、面向对象和泛型编程的高效语言，一直以来都吸引着无数程序员。

而C++11标准引入的Lambda表达式更是为C++注入了新鲜血液。Lambda表达式简洁、易于理解，让我们在编程时能够更高效地表达自己的思想。本文将深入探讨C++ Lambda表达式的基本概念、语法、应用场景以及性能方面的知识。通过这篇文章，您将了解到Lambda表达式的强大功能，并学会如何在实际项目中灵活运用，提升编程效率和代码质量。现在，就让我们一起探索C++ Lambda表达式的魅力之旅吧！

Lambda表达式简介与基本概念 (Introduction and Basic Concepts of Lambda Expressions)

lambda表达式是一个编译器生成的闭包类型（匿名的可调用对象），它重载了 operator()。所以，您可以认为lambda表达式的核心是实现了 operator() 的类型。使用 operator()，lambda表达式表现为函数类似的行为，可以像调用普通函数一样调用lambda表达式。

a. 匿名函数 (Anonymous Functions)

Lambda表达式来源于数学中的λ演算，是一种可以定义在任何地方且没有名称的函数。在C++中，Lambda表达式作为一种轻量级的匿名函数实现，可以实现函数式编程范式，让我们能够编写更简洁、灵活的代码。与普通函数相比，Lambda表达式具有更高的局部性和自包含性，因为它可以直接捕获其所在作用域的变量，这使得Lambda表达式非常适合用于定义简短的一次性函数，尤其是在使用算法库时。

b. 闭包 (Closures)

闭包是指一个函数与其引用环境的组合。在C++中，Lambda表达式可以捕获所在作用域中的局部变量，形成闭包。闭包可以存储捕获变量的状态，即使Lambda表达式的执行上下文已经消失，闭包仍然保持有效。这使得Lambda表达式在处理异步编程、事件驱动编程等场景时具有优势。

c. 自动类型推导 (Automatic Type Deduction)

C++11中引入的自动类型推导功能允许编译器在编译期间推断出一个表达式的类型，而无需显式地声明。Lambda表达式可以利用自动类型推导功能自动推断出其参数类型、返回类型，使得代码更加简洁易读。例如，我们可以使用auto关键字直接定义一个Lambda表达式，而无需声明具体类型。这大大提高了编程效率和代码的可维护性。

C++中的Lambda表达式详解 (In-depth Explanation of C++ Lambda Expressions)

a. 语法结构 (Syntax Structure)

Lambda表达式的基本语法结构包括捕获列表、参数列表、可选的返回类型以及函数体。捕获列表定义了哪些外部变量可以被Lambda表达式访问，参数列表定义了Lambda表达式的输入参数。以下是一个Lambda表达式的示例：

auto example_lambda = [](int x, int y) -> int { return x + y; };

1
2

b.Lambda表达式原型

//(1)
[ captures ] ( params ) specs requires(optional) { body }   
//(2)  (until C++23) 
[ captures ] specs { body }  
//(3)  (since C++20)
[ captures ] < tparams > requires(optional) ( params ) specs requires(optional) { body }
//(4)  (since C++23)
[ captures ] < tparams > requires(optional) specs { body }
//其中 capture 是捕获列表，params 是参数表，
//optional是函数选项，ret 是返回值类型，body是函数体。
//specs  -  consists of specifiers, exception, attr and trailing-return-type in that order; each of these components is optional
1
2
3
4
5
6
7
8
9
10
11

c. 捕获方式 (Capture Modes)

捕获列表支持多种捕获模式，包括值捕获、引用捕获、隐式值捕获和隐式引用捕获。值捕获是以传值方式捕获变量，这意味着在Lambda表达式中使用的是变量的副本。引用捕获是以传引用方式捕获变量，这意味着在Lambda表达式中使用的是变量的引用。隐式值捕获和隐式引用捕获则可以一次性捕获所有变量，分别使用=, &表示。捕获列表还可以混合使用这些捕获模式，根据实际需要灵活选择。

零个或多个捕获的逗号分隔列表，可选择以捕获默认值开头。

lambda 表达式还可以通过捕获列表捕获一定范围内的变量：

• [] 不捕获任何变量。
• [&] 捕获外部作用域中所有变量，并作为引用在函数体中使用（按引用捕获）。
• [=] 捕获外部作用域中所有变量，并作为副本在函数体中使用（按值捕获）。
• [=，&foo] 按值捕获外部作用域中所有变量，并按引用捕获 foo 变量。
• [a, &b] 以值的方式捕获a，引用的方式捕获b，也可以捕获多个。
• [bar] 按值捕获 bar 变量，同时不捕获其他变量。
• [this] 捕获当前类中的 this 指针，让 lambda 表达式拥有和当前类成员函数同样的访问权限。如果已经使用了 & 或者 =，就默认添加此选项。捕获 this 的目的是可以在 lamda 中使用当前类的成员函数和成员变量。

d.捕获示例

假设有一个书本信息的列表，定义如下。我们想要找出其中 title 包含某个关键字（target）的书本的数量，可以通过标准库中的 std::count_if + Lambda 表达式来实现。

struct Book {

  int id; 

  std::string title;

  double price;

};
std::vector<Book> books;

std::string target = "C++";  // 找出其中 title 包含“C++”的书本的数量
1
2
3
4
5
6
7
8
9
10
11
12

• 按值捕获(Capture by Value)

  auto cnt = std::count_if(books.begin(), books.end(), [target](const Book& book) {
          return book.title.find(target) != std::string::npos;
      }); 
  1
  2
  3

• 按引用捕获（Capture by Reference）

  auto cnt =
      std::count_if(books.begin(), books.end(), [&target](const Book& book) {
          return book.title.find(target) != std::string::npos;
      }); 
  1
  2
  3
  4

• 捕获列表初始化（Capture Initializers）

在 C++14 中，Lambda 表达式得到了增强，特别是在捕获列表的使用上。捕获列表初始化（Capture Initializers）是一个新增特性，它允许在 Lambda 表达式中创建新变量。这种方法对于捕获外部变量而不改变其原有名字非常有用。让我们以一个详细的例子来解释这个特性，我将在代码中添加完整的 Doxygen 注释以便更好地理解。

#include <algorithm>
#include <vector>
#include <string>

// 定义一个书籍的结构体
struct Book {
    std::string title;
    // 可以添加更多书籍相关的属性
};

int main() {
    std::vector<Book> books = {
        // 初始化一些书籍
        {"C++ Primer"},
        {"Effective Modern C++"},
        {"The C++ Programming Language"}
    };

    std::string target = "C++";

    // 使用 Lambda 按值捕获 target，但在 Lambda 内部变量名为 v
    // @param books 书籍的集合
    // @param target 要搜索的目标字符串
    // @return 符合条件的书籍数量
    auto count_by_value = [&books, target]() {
        return std::count_if(books.begin(), books.end(), [v = target](const Book& book) {
            return book.title.find(v) != std::string::npos;
        });
    };

    // 使用 Lambda 按引用捕获 target，但在 Lambda 内部变量名为 r
    // @param books 书籍的集合
    // @param target 要搜索的目标字符串
    // @return 符合条件的书籍数量
    auto count_by_reference = [&books, &target]() {
        return std::count_if(books.begin(), books.end(), [&r = target](const Book& book) {
            return book.title.find(r) != std::string::npos;
        });
    };

    int cnt_by_value = count_by_value(); // 按值捕获计数
    int cnt_by_reference = count_by_reference(); // 按引用捕获计数

    // 输出结果
    std::cout << "Count by value: " << cnt_by_value << std::endl;
    std::cout << "Count by reference: " << cnt_by_reference << std::endl;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

在这个例子中，我们定义了一个 Book 结构体，包含书籍的标题。然后，我们创建了一个包含几本书的 std::vector。接着，我们使用 Lambda 表达式来计数向量中标题包含特定字符串（在这个例子中是 “C++”）的书籍数量。我们分别展示了按值捕获和按引用捕获的用法。Lambda 表达式中，[v = target] 和 [&r = target] 分别表示按值捕获 target 并在 Lambda 内部以 v 命名，以及按引用捕获 target 并在 Lambda 内部以 r 命名。这样的写法增加了代码的灵活性和可读性。

e. 使用场景与优势 (Use Cases and Advantages)

Lambda表达式的使用场景包括但不限于：替换小型函数、简化STL算法和函数适配器、实现回调函数和事件处理、以及简化并行和异步编程。使用Lambda表达式的优势在于：

• 简化语法，提高代码可读性和可维护性
  不需要额外再写一个函数或者函数对象，避免了代码膨胀和功能分散，让开发者更加集中精力在手边的问题，同时也获取了更高的生产率。

• 更好的性能，编译器可以进行内联优化

• 声明式编程风格：就地匿名定义目标函数或函数对象，不需要额外写一个命名函数或者函数对象.减少代码冗余。

• 以更直接的方式去写程序，好的可读性和可维护性.更好地支持函数式编程范式，使代码更加通用和可复用

• 在需要的时间和地点实现功能闭包，使程序更灵活。

实际应用案例 (Practical Examples)

a.使用Lambda表达式简化算法 (Simplifying Algorithms with Lambda Expressions)

C++标准库中包含许多算法，如sort、for_each、transform等，使用Lambda表达式可以使这些算法更加简洁和灵活。例如，对一个整数向量进行排序，我们可以使用Lambda表达式自定义排序规则：

std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5};
std::sort(numbers.begin(), numbers.end(), [](int a, int b) { return a > b; });

1
2
3

b. 在容器操作中使用Lambda (Using Lambda in Container Operations)

Lambda表达式可以与C++标准库中的容器结合使用，实现更加简洁和高效的容器操作。例如，我们可以使用std::for_each遍历一个向量，并将其中的每个元素加倍：

std::vector<int> numbers = {1, 2, 3, 4, 5};
std::for_each(numbers.begin(), numbers.end(), [](int &n) { n *= 2; });

1
2
3

c. 异步编程与Lambda (Asynchronous Programming and Lambda)

在异步编程中，Lambda表达式可以作为回调函数或任务，简化异步任务的创建和调度。例如，我们可以使用std::async启动一个异步任务，计算斐波那契数列的第n项：

#include <future>

auto fibonacci = [](int n) {
    int a = 0, b = 1;
    for (int i = 0; i < n; ++i) {
        int temp = a;
        a = b;
        b = temp + b;
    }
    return a;
};

std::future<int> result = std::async(std::launch::async, fibonacci, 10);
int value = result.get(); // 获取异步任务的结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

通过这些实际应用案例，我们可以看到Lambda表达式在编程中的强大功能和优势。

Lambda表达式的高级用法 (Advanced Usage of Lambda Expressions)

a. Lambda表达式中的条件表达式 (Conditional Expressions in Lambda)

Lambda表达式可以使用条件表达式进行复杂的逻辑判断，例如实现多种排序规则：

auto custom_sort = [](bool ascending) {
    return [ascending](int a, int b) {
        return ascending ? a < b : a > b;
    };
};

std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5};
std::sort(numbers.begin(), numbers.end(), custom_sort(true)); // 升序排序
std::sort(numbers.begin(), numbers.end(), custom_sort(false)); // 降序排序

1
2
3
4
5
6
7
8
9
10

b. 嵌套Lambda表达式 (Nested Lambda Expressions)

Lambda表达式可以嵌套在其他Lambda表达式中，实现高级功能。例如，下面的代码定义了一个高阶函数compose，用于组合两个函数：

auto compose = [](auto f1, auto f2) {
    return [f1, f2](auto x) { return f1(f2(x)); };
};

auto square = [](int x) { return x * x; };
auto increment = [](int x) { return x + 1; };

auto square_then_increment = compose(increment, square);
auto result = square_then_increment(3); // 结果为10 (3 * 3 + 1)

1
2
3
4
5
6
7
8
9
10

c. 使用Lambda表达式实现惰性求值 (Lazy Evaluation with Lambda Expressions)

Lambda表达式可以用于实现惰性求值，即在需要结果的时候才进行计算。这在处理大量数据或计算代价较高的场景中非常有用。例如，我们可以使用Lambda表达式实现一个惰性求和函数：

auto lazy_sum = [](auto container) {
    return [container]() {
        return std::accumulate(container.begin(), container.end(), 0);
    };
};

std::vector<int> numbers = {1, 2, 3, 4, 5};
auto sum = lazy_sum(numbers);
// ... 其他操作
int result = sum(); // 在需要时进行求和计算

1
2
3
4
5
6
7
8
9
10
11

以上高级用法展示了Lambda表达式在实际编程中的强大潜力，它们可以帮助我们编写出更简洁、高效的代码。这些技巧只是Lambda表达式的冰山一角，掌握了这些高级用法，将有助于您更好地发挥Lambda表达式的威力。

Qt中的lambda运用

qt创建线程使用lambda表达式

Qt中创建线程可以使用QThread类。在某些情况下，我们可能需要使用lambda表达式与QThread结合。例如，当我们想要在子线程中运行简单的任务时，可以利用lambda表达式实现。以下是一个使用lambda表达式与QThread结合的例子：

#include <QCoreApplication>
#include <QThread>
#include <QDebug>

int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);

    QThread *thread = new QThread();
    QObject::connect(thread, &QThread::started, [&]() {
        qDebug() << "Thread started, running tasks...";
        // 在这里执行任务
        // ...

        qDebug() << "Tasks completed.";
        thread->quit(); // 结束线程
    });

    QObject::connect(thread, &QThread::finished, [&]() {
        qDebug() << "Thread finished.";
        thread->deleteLater(); // 删除线程对象
        app.quit(); // 退出应用
    });

    thread->start(); // 开始线程

    return app.exec();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

在这个例子中，我们创建了一个QThread对象，并通过lambda表达式将其started信号与一个匿名函数连接，以便在子线程中执行任务。同样地，我们将finished信号与另一个lambda表达式连接，以便在子线程完成时执行相应的操作。

尽管如此，这种方法并不是Qt推荐的线程使用方式。在实际项目中，Qt建议使用QThread的子类化方法，并将耗时任务放在子类的run()方法中。不过，对于一些简单的场景，使用lambda表达式与QThread结合仍然是一个方便的选择。

connect使用lambda表达式

在Qt中，使用connect()函数连接信号和槽是非常常见的。通常情况下，我们需要定义槽函数并将其与信号关联。然而，在某些情况下，为了简化代码或者方便快速实现功能，我们可以使用lambda表达式作为槽函数。以下是关于在connect()中使用lambda表达式的一些详细内容：

1. 基本用法： 使用lambda表达式作为槽函数时，我们不再需要在类中定义槽函数。而是可以直接在connect()中编写槽函数逻辑。基本语法如下：

   connect(sender, &SenderClass::signal, this, [this]() {
       // 槽函数逻辑
   });
   
   1
   2
   3
   4

   例如，我们可以在一个按钮的clicked信号中使用lambda表达式：

   QPushButton *button = new QPushButton("Click me");
   connect(button, &QPushButton::clicked, this, [this]() {
       qDebug() << "Button clicked!";
   });
   
   1
   2
   3
   4
   5

2. 捕获列表： 在lambda表达式中，我们可以使用捕获列表来捕获外部变量。捕获列表支持值捕获和引用捕获。[=]表示值捕获，[&]表示引用捕获。我们还可以选择捕获特定的变量，例如[this, &var1, var2]。

   int value = 0;
   connect(button, &QPushButton::clicked, this, [this, value]() {
       qDebug() << "Button clicked with value:" << value;
   });
   
   1
   2
   3
   4
   5

3. 带参数的槽函数： lambda表达式可以接受参数，类似于普通函数。这使得我们可以在信号槽连接中捕获信号传递的参数。

   QSlider *slider = new QSlider(Qt::Horizontal);
   connect(slider, &QSlider::valueChanged, this, [this](int value) {
       qDebug() << "Slider value changed:" << value;
   });
   
   1
   2
   3
   4
   5

4. 使用mutable关键字： 在某些情况下，我们可能需要修改捕获的变量。默认情况下，lambda表达式不允许修改值捕获的变量。为了允许修改值捕获的变量，我们需要使用mutable关键字。

   int counter = 0;
   connect(button, &QPushButton::clicked, this, [=]() mutable {
       counter++;
       qDebug() << "Button clicked" << counter << "times";
   });
   
   1
   2
   3
   4
   5
   6

异步操作使用lambda表达式

在Qt中，某些类可以利用lambda表达式进行异步操作。这种方法可以让我们在不定义槽函数的情况下，更简洁地处理异步事件。以下是一些使用lambda表达式进行异步操作的例子：

1. QTimer:

   QTimer提供了定时器功能，可以在给定的时间间隔后发出超时信号。通常我们会将QTimer的超时信号与槽函数连接。然而，使用lambda表达式，我们可以直接在连接时定义回调逻辑。

   例如，我们可以使用QTimer的singleShot()函数创建一个只触发一次的定时器：

   QTimer::singleShot(1000, [this]() {
       qDebug() << "One second has passed!";
   });
   
   1
   2
   3
   4

   在这个例子中，当定时器触发时，lambda表达式中的代码将被执行。

   如果我们需要一个重复触发的定时器，可以这样做：

   QTimer *timer = new QTimer(this);
   timer->setInterval(1000);
   
   connect(timer, &QTimer::timeout, this, [this]() {
       qDebug() << "One second has passed!";
   });
   
   timer->start();
   
   1
   2
   3
   4
   5
   6
   7
   8
   9

2. QFutureWatcher:

   QFutureWatcher可以用于监视异步计算任务。当任务完成时，QFutureWatcher会发出相应的信号。我们可以将这些信号与lambda表达式连接，以便在任务完成时执行回调逻辑。

   例如，我们可以在一个异步任务完成时，使用lambda表达式处理结果：

   QFutureWatcher<int> *watcher = new QFutureWatcher<int>(this);
   
   connect(watcher, &QFutureWatcher<int>::finished, this, [this, watcher]() {
       int result = watcher->result();
       qDebug() << "Task completed with result:" << result;
   });
   
   QFuture<int> future = QtConcurrent::run([]() {
       // 异步任务逻辑
       return 42;
   });
   
   watcher->setFuture(future);
   
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14

   在这个例子中，我们使用QtConcurrent::run()启动了一个异步任务。当任务完成时，QFutureWatcher的finished信号将被触发。我们使用lambda表达式连接了这个信号，并在其中处理任务的结果。

   这些例子展示了如何在Qt中使用lambda表达式进行异步操作。利用lambda表达式可以让我们更简洁地处理异步事件，提高代码可读性。然而，同样需要注意在实际项目中不要过度使用lambda表达式，以免导致代码难以理解和维护。

Lambda表达式的性能与效率 (Performance and Efficiency of Lambda Expressions)

a. 编译器优化 (Compiler Optimizations)

Lambda表达式在运行时通常具有较高的性能，因为编译器可以对它们进行优化。例如，内联优化是一种常见的优化手段，可以减少函数调用的开销。通过将Lambda表达式内联展开，编译器可以有效地优化生成的代码，提高运行时性能。

b. 常见陷阱与注意事项 (Common Pitfalls and Precautions)

• lambda函数是一个closure（闭包）类型的函数；
• lambda函数在编译时进行转换；
• lambda捕获的值是否可以修改，需要确认是否有mutable修饰。
• 默认引用捕获可能带来的悬挂引用问题
• 引用捕获陷阱：引用捕获[&]别使用****局部变量
• this陷阱：lambda里避免有全局变量或静态变量或者比当前类生命周期更长****的变量
• 尽量避免使用****复杂的lambda

尽管Lambda表达式具有诸多优势，但在使用过程中仍需注意一些陷阱和注意事项：

1. 捕获列表中的生命周期：当使用引用捕获变量时，务必确保捕获的变量在Lambda表达式执行期间仍然有效。否则，可能导致未定义行为。
2. 闭包的复制与传递：Lambda表达式生成的闭包对象可以像普通对象一样进行复制和传递。然而，需要注意的是，当闭包对象捕获了大量数据时，复制和传递可能导致性能下降。
3. Lambda表达式的递归调用：Lambda表达式本身无法直接进行递归调用，因为它没有名称。在需要递归调用时，可以使用std::function包装Lambda表达式，然后进行递归调用。

常见问题与答疑 (Frequently Asked Questions)

在使用Lambda表达式时，很多开发者可能会遇到一些问题。在本章节中，我们将回答一些与Lambda表达式相关的常见问题。

a. 如何将Lambda表达式作为函数参数传递？ (How to pass a Lambda expression as a function parameter?)

传递Lambda表达式作为函数参数时，我们可以使用std::function和模板参数两种方式。std::function提供了一种通用的函数类型，可以容纳各种可调用对象，包括Lambda表达式。使用模板参数可以保留Lambda表达式的类型信息，避免额外的性能开销。

#include <functional>

// 使用std::function作为参数
void execute_function(const std::function<int(int, int)> &func, int x, int y) {
    int result = func(x, y);
    // ... 其他操作
}

// 使用模板参数作为参数
template <typename Callable>
void execute_template(const Callable &func, int x, int y) {
    int result = func(x, y);
    // ... 其他操作
}

auto sum = [](int a, int b) { return a + b; };
execute_function(sum, 3, 5);
execute_template(sum, 3, 5);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

b. Lambda表达式如何访问类成员变量？ (How can a Lambda expression access class member variables?)

Lambda表达式可以通过捕获类的this指针来访问成员变量。以下代码展示了如何在Lambda表达式中访问类的成员变量：

class MyClass {
public:
    void modify_member() {
        auto modify_lambda = [this] { member_ += 1; };
        modify_lambda();
    }

private:
    int member_ = 0;
};

1
2
3
4
5
6
7
8
9
10
11

c. 如何在Lambda表达式中使用nothrow？ (How to use nothrow in Lambda expressions?)

nothrow是C++中的一种异常规范，它表示函数不会抛出任何异常。在Lambda表达式中，可以通过在函数体之前添加nothrow关键字来指定异常规范：

auto nothrow_lambda = [](int x, int y) noexcept {
    return x + y;
};

1
2
3
4

请注意，nothrow仅用于指定函数的异常规范，并不意味着函数一定不会抛出异常。在实际编程中，我们需要确保Lambda表达式的实现与声明的异常规范一致。

d. 如何创建可变Lambda表达式？ (How to create a mutable Lambda expression?)

默认情况下，Lambda表达式中的所有变量都是const，因此无法在Lambda表达式中修改捕获的变量。然而，我们可以使用mutable关键字来创建可变Lambda表达式，这样可以修改捕获的值变量：

int counter = 0;
auto mutable_lambda = [counter]() mutable {
    counter++;
    std::cout << "Counter: " << counter << std::endl;
};

mutable_lambda(); // 输出：Counter: 1
mutable_lambda(); // 输出：Counter: 2

1
2
3
4
5
6
7
8
9

请注意，mutable关键字仅适用于值捕获的变量。对于引用捕获的变量，不需要使用mutable关键字，因为它们本身就可以被修改。

e. 如何将Lambda表达式转换为函数指针？ (How to convert a Lambda expression to a function pointer?)

仅在Lambda表达式不捕获任何外部变量时，它才可以被转换为函数指针。以下代码展示了如何将Lambda表达式转换为函数指针：

auto lambda = [](int x, int y) { return x + y; };
using FunctionPtrType = int (*)(int, int);
FunctionPtrType func_ptr = lambda;

int result = func_ptr(3, 5); // 结果为8

1
2
3
4
5
6

需要注意的是，如果Lambda表达式捕获了外部变量，将无法转换为函数指针。

f. Lambda表达式能否捕获全局变量？ (Can a Lambda expression capture global variables?)

Lambda表达式不能直接捕获全局变量，因为全局变量在整个程序的生命周期内都是可访问的。然而，您可以在Lambda表达式中直接使用全局变量。以下代码展示了如何在Lambda表达式中访问全局变量：

#include <iostream>

int global_variable = 0;

int main() {
    auto lambda = [] {
        global_variable += 1;
        std::cout << "Global variable: " << global_variable << std::endl;
    };

    lambda(); // 输出：Global variable: 1
    lambda(); // 输出：Global variable: 2

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

g.如何创建一个只接受lambda表达式形参的函数？（How do I create a function that only accepts formal parameters of an lambda expression?）

为了创建一个能够仅接受lambda表达式的函数，可以使用模板技术并对可调用对象的类型进行约束。在这种情况下，您可以使用 std::enable_if_t 和 std::is_constructible 来限制输入类型仅包括函数对象（Functor）。

在这个示例中，我们定义了一个接受具有 operator() 的类型的函数，从而实现仅接受lambda表达式的目的：

#include <iostream>
#include <type_traits>

template<typename F,
         typename = std::enable_if_t<!std::is_function<F>::value &&
                                     std::is_constructible<F>::value>>
void myFunction(F func) {
    func();
}

int main() {
    // 创建一个 lambda 表达式
    auto myLambda = []() {
        std::cout << "Hello, lambda!" << std::endl;
    };

    // 将 lambda 表达式作为参数传递给 myFunction
    myFunction(myLambda);  // 有效的调用

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

上述代码中，myFunction 函数模板使用类型约束确保函数仅接受具有 operator() 的类型，从而使其只接受闭包类型（例如 lambda 表达式）或自定义的可调用对象（Functor）。 这样，在尝试将普通函数作为参数传递给 myFunction 时，这样的调用将被禁止，而仅允许lambda表达式通过编译。
通过这些额外的问题答疑，我们希望能够帮助您在使用Lambda表达式时遇到的其他问题，使您更加熟练地运用Lambda表达式解决实际编程问题。

C++标准的发展与Lambda表达式 (Evolution of C++ Standards and Lambda Expressions)

a.C++11中的Lambda (Lambda in C++11)

C++11标准首次引入了Lambda表达式，为C++程序员提供了一种简洁、强大的编程工具。C++11中的Lambda表达式支持基本的值捕获、引用捕获和自动类型推导等功能。

b. C++14中的Lambda扩展 (Lambda Extensions in C++14)

C++14对Lambda表达式进行了扩展，引入了泛型Lambda和自动返回类型推导等新特性。泛型Lambda允许使用auto作为参数类型，使得Lambda表达式具有更好的通用性和可复用性。
在 C++14 中，Lambda 表达式得到了一些重要的扩展，其中最显著的是引入了泛型 Lambda 和自动返回类型推导。这些改进大大增强了 Lambda 表达式的通用性和灵活性。

我将提供一个详细的示例，演示如何使用 C++14 中的泛型 Lambda，并为其添加完整的 Doxygen 注释。

示例：泛型 Lambda 表达式

/**
 * @brief 一个演示泛型 Lambda 表达式的示例。
 *
 * 该 Lambda 表达式使用 auto 关键字来定义一个泛型参数。它能够接受任何类型的参数，并将其打印到标准输出。
 * 使用泛型 Lambda 可以提高代码的可重用性和灵活性。
 *
 * @tparam T 泛型参数类型，由调用 Lambda 时传入的实际参数类型决定。
 * @param value 一个泛型参数，Lambda 表达式将打印其值。
 * @return 无返回值。
 */
auto genericLambda = [](auto value) {
    std::cout << "The value is: " << value << std::endl;
};

int main() {
    // 使用 int 类型
    genericLambda(10);

    // 使用 string 类型
    genericLambda(std::string("Hello, World!"));

    // 使用自定义类型
    struct CustomType { int x; };
    genericLambda(CustomType{42});

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

在这个例子中，genericLambda 是一个泛型 Lambda 表达式。它接受一个类型为 auto 的参数 value。由于使用了 auto，这个 Lambda 可以接受任何类型的参数。

在 main 函数中，我们展示了如何使用不同类型的参数来调用这个泛型 Lambda，包括基本类型（如 int）、标准库类型（如 std::string）以及自定义类型。

这个示例展示了 C++14 Lambda 表达式的强大灵活性，同时也体现了 Doxygen 注释的规范写法，有助于代码的理解和维护。

c. C++17与C++20中的新增功能 (New Features in C++17 and C++20)

C++17和C++20标准中进一步完善了Lambda表达式，包括引入constexpr Lambda和模板参数捕获等功能。这些改进使得Lambda表达式更加强大和灵活，可以应对更多的编程场景。
C++17和C++20为Lambda表达式引入了一些显著的改进，使得它们更加强大和灵活。以下是一个详细的例子，展示了这些新特性，同时加上了完整的Doxygen注释。

例子：使用C++17和C++20的Lambda特性

假设我们有一个需求：创建一个Lambda表达式，它可以捕获模板参数，并且是constexpr，以便在编译时进行计算。

#include <iostream>
#include <array>

// 使用Doxygen注释来描述函数
/**
 * @brief 示例函数，展示C++17和C++20中Lambda的新特性
 * 
 * @tparam T 模板参数，用于Lambda捕获
 * @param value 用于Lambda表达式的值
 * @return constexpr T 返回经过Lambda处理的值
 */
template <typename T>
constexpr T exampleFunction(T value) {
    // C++17: 允许Lambda表达式具有auto类型的参数
    auto lambda = [value](auto x) { return x * value; };

    // C++20: constexpr Lambda
    constexpr auto result = lambda(10);
    return result;
}

int main() {
    // 使用exampleFunction
    constexpr int result = exampleFunction(5);
    std::cout << "Result: " << result << std::endl; // 输出: Result: 50
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

在这个例子中，我们定义了一个模板函数exampleFunction，它接受一个类型为T的参数value。在函数内部，我们创建了一个Lambda表达式lambda，它捕获了value并接受一个自动推导类型的参数x。这个Lambda简单地将x和value相乘。

随后，我们使用C++20的特性来声明一个constexpr变量result，它在编译时就会被计算，存储了Lambda表达式的结果。

这个例子展示了C++17的自动类型推导Lambda参数和C++20的constexpr Lambda的结合使用，为编写更灵活且高效的模板代码提供了便利。通过这些特性，可以在编译时执行更多的计算，从而提高运行时的性能。

从编译器底层和内存角度看Lambda表达式及其与其他函数的区别(Lambda expressions and their differences from other functions from the Perspective of Compiler bottom layer and memory)

在这一章节中，我们将深入探讨Lambda表达式在编译器底层和内存方面的工作原理，以及它与其他函数之间的差异。

// Lambda表达式
auto lambda = [x](int y) { return x + y; };

// 底层闭包类型实现
class Closure {
public:
    explicit Closure(int x) : x_(x) {}
    int operator()(int y) const { return x_ + y; }

private:
    int x_;
};

1
2
3
4
5
6
7
8
9
10
11
12
13

a. Lambda表达式的底层实现 (Underlying Implementation of Lambda Expressions)

Lambda表达式在底层被编译器转换为一个匿名类（称为闭包类型），该类具有一个重载的调用运算符。Lambda表达式捕获的变量会被嵌入到闭包类型的数据成员中。以下是一个简化的Lambda表达式的底层实现示例：

// Lambda表达式
auto lambda = [x](int y) { return x + y; };

// 底层闭包类型实现
class Closure {
public:
    explicit Closure(int x) : x_(x) {}
    int operator()(int y) const { return x_ + y; }

private:
    int x_;
};

1
2
3
4
5
6
7
8
9
10
11
12
13

b. 内存使用 (Memory Usage)

Lambda表达式的内存使用取决于它捕获的变量以及是否使用引用捕获。值捕获的变量会被复制到闭包类型的数据成员中，而引用捕获的变量则以引用形式存储。使用引用捕获通常可以减少内存使用，但需要注意引用的生命周期。

此外，如果Lambda表达式没有捕获任何外部变量，则其内存使用与普通函数相似。在这种情况下，编译器可能会为其生成与普通函数相同的代码。

c. 与其他函数的区别 (Difference from Other Functions)

Lambda表达式与普通函数和函数对象（functors）在底层实现和内存使用上有一定的差异：

• 普通函数：普通函数不包含任何状态信息，且在底层实现上更简单。然而，普通函数不能直接捕获外部变量，通常需要使用函数参数来传递所需的信息。
• 函数对象（functors）：函数对象类似于Lambda表达式，它们都是通过类实现的，具有重载的调用运算符。不过，与Lambda表达式相比，手动实现函数对象通常更加繁琐，而Lambda表达式的语法更为简洁。

总之，Lambda表达式作为一种强大的编程工具，其在编译器底层和内存使用上表现出一定的灵活性和优势。相较于普通函数和函数对象，Lambda表达式提供了更简洁的语法和更方便的捕获机制，使得程序员能够更高效地编写代码。

结语

使用Lambda表达式具有一系列优势，使得程序员在编程过程中能够更加高效、聚焦，并降低心理负担。

1. 降低心理负担：Lambda表达式的简洁性使得代码更加易读、易懂。编写简洁的代码有助于降低程序员在阅读、理解和维护代码时的心理负担。同时，它还有助于减少错误和潜在的bug。
2. 提高认知效率：Lambda表达式通过将相关的代码逻辑组织在一起，能够提高程序员在处理复杂问题时的认知效率。使用Lambda表达式可以帮助程序员将注意力集中在重要的业务逻辑上，而无需过多关注实现细节。
3. 创造力的激发：Lambda表达式的灵活性和表达能力使得程序员可以更加自由地发挥创意，设计出富有创造力的解决方案。这有助于激发程序员在编程过程中的创造力和探索精神。
4. 高度的自主性与满足感：Lambda表达式提供了一种高度自主的编程方法，使得程序员能够根据实际需求和个人风格来灵活选择使用Lambda表达式。当程序员成功运用Lambda表达式解决问题时，他们将获得更高的成就感和满足感。
5. 提升编程效率：Lambda表达式可以简化许多编程任务，使得程序员能够更快地完成项目。这有助于提高整体的编程效率，使得团队在开发过程中能够更好地协同合作，实现更高的生产力。

综上所述，Lambda表达式作为一种强大的编程工具，从心理学的角度来看，它有助于提高程序员的认知效率、激发创造力、降低心理负担、提升自主性和满足感，以及提高编程效率。因此，学习并掌握Lambda表达式对于程序员而言具有重要的价值。

在我们的编程学习之旅中，理解是我们迈向更高层次的重要一步。然而，掌握新技能、新理念，始终需要时间和坚持。从心理学的角度看，学习往往伴随着不断的试错和调整，这就像是我们的大脑在逐渐优化其解决问题的“算法”。

这就是为什么当我们遇到错误，我们应该将其视为学习和进步的机会，而不仅仅是困扰。通过理解和解决这些问题，我们不仅可以修复当前的代码，更可以提升我们的编程能力，防止在未来的项目中犯相同的错误。

我鼓励大家积极参与进来，不断提升自己的编程技术。无论你是初学者还是有经验的开发者，我希望我的博客能对你的学习之路有所帮助。如果你觉得这篇文章有用，不妨点击收藏，或者留下你的评论分享你的见解和经验，也欢迎你对我博客的内容提出建议和问题。每一次的点赞、评论、分享和关注都是对我的最大支持，也是对我持续分享和创作的动力。

---

阅读我的CSDN主页,解锁更多精彩内容:泡沫的CSDN主页