C++ `constexpr` `lambda` 表达式 (C++17)：编译期匿名函数的强大 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

哈喽，各位好！今天咱们来聊聊C++17里的一个宝藏功能：constexpr lambda表达式。这玩意儿乍一听有点吓人，又是constexpr又是lambda的，感觉很高级。其实没那么玄乎，咱们用大白话把它掰开了揉碎了，保证你听完之后也能用它秀一把。

什么是Lambda表达式？（先打个底）

在深入constexpr之前，咱们先回顾一下Lambda表达式。简单来说，Lambda表达式就是一个匿名函数。啥叫匿名函数？就是没有名字的函数。想象一下，你定义了一个函数，但是懒得给它起名字，直接用它干活，这就是Lambda。

Lambda表达式的基本语法是这样的：

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

[capture]：捕获列表，用来捕获Lambda表达式外部的变量。
(parameters)：参数列表，和普通函数一样，用来接收参数。
-> return_type：返回类型，可以省略，编译器会自动推导。
{ body }：函数体，就是Lambda表达式要执行的代码。

举个栗子：

auto add = [](int a, int b) -> int { return a + b; };
int sum = add(3, 5); // sum = 8

在这个例子里，我们定义了一个Lambda表达式，它接收两个int类型的参数a和b，返回它们的和。然后我们把这个Lambda表达式赋值给add变量，就可以像调用普通函数一样调用它了。

constexpr：编译期计算的魔法

constexpr是C++11引入的一个关键字，它的作用是告诉编译器，这个变量或者函数可以在编译期求值。也就是说，如果编译器能在编译的时候算出结果，那就不要等到运行的时候再算了，直接把结果写到编译后的代码里。

这有什么好处呢？好处可大了！

性能提升：编译期计算可以减少运行时的计算量，提高程序的性能。
编译期检查：有些错误只有在运行的时候才能发现，但是如果使用了constexpr，编译器就可以在编译期进行检查，提前发现错误。
模板元编程：constexpr是模板元编程的基础，可以实现一些复杂的编译期计算。

constexpr Lambda表达式：强强联合

现在，我们把constexpr和Lambda表达式结合起来，就得到了constexpr Lambda表达式。它的意思就是，这个Lambda表达式可以在编译期求值。

要让Lambda表达式成为constexpr，需要满足一些条件：

必须是字面类型：Lambda表达式的返回类型和参数类型必须是字面类型。字面类型就是可以在编译期确定的类型，比如int、float、char等等。
函数体必须足够简单：Lambda表达式的函数体必须足够简单，只能包含一个return语句，或者是一些简单的表达式。不能包含循环、goto语句、try-catch块等等。
不能捕获任何变量：constexpr Lambda表达式不能捕获任何变量，也就是说，捕获列表必须为空，[]。

举个栗子：

constexpr auto square = [](int x) { return x * x; };
constexpr int result = square(5); // result = 25 (编译期计算)

在这个例子里，我们定义了一个constexpr Lambda表达式square，它接收一个int类型的参数x，返回它的平方。由于square是constexpr的，所以square(5)可以在编译期计算，result的值也会在编译期确定。

进阶用法：捕获和泛型

虽然constexpr Lambda表达式不能直接捕获变量，但是我们可以通过一些技巧来间接实现捕获的效果。

模板参数：我们可以把需要捕获的变量作为模板参数传递给Lambda表达式。

template <int N>
constexpr auto add_n = [](int x) { return x + N; };

constexpr int result = add_n<10>(5); // result = 15 (编译期计算)

在这个例子里，我们定义了一个模板Lambda表达式add_n，它接收一个模板参数N，然后把N加到参数x上。这样，我们就实现了类似于捕获的效果。

立即调用Lambda表达式 (Immediately Invoked Lambda Expression, IILE)：我们可以将需要“捕获”的变量作为参数传递给一个Lambda表达式，并立即调用它。这在C++17中可以结合constexpr。

constexpr auto result = [] (int captured_value) constexpr {
        return captured_value * captured_value;
    }(5); // result = 25

泛型constexpr Lambda

C++14引入了泛型Lambda，可以进一步增强constexpr Lambda表达式的灵活性。这意味着Lambda表达式的参数类型可以自动推导，无需显式指定。

constexpr auto generic_square = [](auto x) { return x * x; };

constexpr int int_result = generic_square(5); // int_result = 25
constexpr double double_result = generic_square(5.5); // double_result = 30.25

注意事项和限制

编译器支持：constexpr Lambda表达式是C++17的新特性，需要较新的编译器才能支持。如果你的编译器不支持，你需要升级你的编译器。
函数体的限制：constexpr Lambda表达式的函数体必须足够简单，不能包含复杂的逻辑。一般来说，只能包含一个return语句，或者是一些简单的表达式。
调试困难：由于constexpr Lambda表达式是在编译期求值的，所以调试起来比较困难。如果你的代码出现了问题，你需要仔细检查你的代码，或者使用一些编译期调试工具。

应用场景

constexpr Lambda表达式有很多应用场景，比如：

编译期计算常量：我们可以使用constexpr Lambda表达式来计算一些常量，比如阶乘、斐波那契数列等等。

constexpr auto factorial = [](int n) {
    int result = 1;
    for (int i = 1; i <= n; ++i) {
        result *= i;
    }
    return result;
};

constexpr int fact_5 = factorial(5); // fact_5 = 120

（注意，上面的例子在C++17中是不合法的，因为factorial函数体包含循环。但是，可以使用递归的方法实现，如下所示。）

constexpr auto factorial = [](int n) {
    return (n <= 1) ? 1 : n * factorial(n - 1);
};

constexpr int fact_5 = factorial(5); // fact_5 = 120

编译期排序：我们可以使用constexpr Lambda表达式来实现编译期排序，对数组进行排序。

#include <algorithm>
#include <array>

constexpr auto sort_array = [](auto& arr) {
    std::sort(arr.begin(), arr.end());
    return arr;
};

constexpr std::array<int, 5> unsorted_array = {5, 2, 4, 1, 3};
constexpr auto sorted_array = sort_array(unsorted_array);

// sorted_array = {1, 2, 3, 4, 5}

（注意：上面的代码片段在严格的C++17标准下仍然可能无法工作，因为std::sort通常不是constexpr。为了实现编译期排序，需要自定义一个constexpr排序算法。）

#include <array>

template <typename T, size_t N>
constexpr std::array<T, N> constexpr_sort(std::array<T, N> arr) {
    for (size_t i = 0; i < N - 1; ++i) {
        for (size_t j = 0; j < N - i - 1; ++j) {
            if (arr[j] > arr[j + 1]) {
                // 交换 arr[j] 和 arr[j+1]
                T temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr;
}

constexpr std::array<int, 5> unsorted_array = {5, 2, 4, 1, 3};
constexpr auto sorted_array = constexpr_sort(unsorted_array);

// sorted_array = {1, 2, 3, 4, 5}

编译期代码生成：我们可以使用constexpr Lambda表达式来生成一些代码，比如生成一些查找表、生成一些配置文件等等。

总结

constexpr Lambda表达式是C++17的一个强大功能，它可以让我们在编译期执行一些计算，提高程序的性能和安全性。虽然它有一些限制，但是只要我们掌握了它的用法，就可以在很多场景下使用它。

一些更实际的例子和表格

为了更具体的理解constexpr Lambda表达式，我们来看一些实际的例子，并用表格总结一些关键点。

例1: 编译期计算字符串长度

constexpr auto string_length = [](const char* str) constexpr {
    size_t len = 0;
    while (*str++) {
        len++;
    }
    return len;
};

constexpr const char* my_string = "Hello, constexpr!";
constexpr size_t string_len = string_length(my_string); // string_len = 17

static_assert(string_len == 17, "String length is incorrect!"); // 编译期断言

例2: 编译期查找数组中的最大值

#include <array>
#include <algorithm> // for std::max

template <typename T, size_t N>
constexpr T constexpr_max(const std::array<T, N>& arr) {
    T max_val = arr[0];
    for (size_t i = 1; i < N; ++i) {
        max_val = std::max(max_val, arr[i]);
    }
    return max_val;
}

constexpr std::array<int, 5> my_array = {1, 5, 2, 8, 3};
constexpr int max_value = constexpr_max(my_array); // max_value = 8

static_assert(max_value == 8, "Max value is incorrect!");

例3: 使用 constexpr Lambda 定义编译期常量表达式

constexpr auto pi = []() constexpr { return 3.14159265358979323846; }(); // IILE

constexpr double circle_area(double radius) {
    return pi * radius * radius;
}

constexpr double area = circle_area(5.0); // area 在编译时计算

static_assert(area > 78.0 && area < 79.0, "Area calculation failed!");

关键点总结

特性	描述	示例
`constexpr`	声明一个变量或函数可以在编译时求值。如果编译器能在编译时计算出结果，则结果成为编译时常量。	`constexpr int x = 5;` , `constexpr int square(int n) { return n * n; }`
Lambda表达式	匿名函数，可以在代码中内联定义和使用，无需提前声明。	`auto add = [](int a, int b) { return a + b; };`
`constexpr` Lambda	`constexpr` Lambda表达式是可以在编译时求值的匿名函数。它结合了`constexpr`和Lambda表达式的优点，允许在编译时进行更复杂的计算。	`constexpr auto square = [](int x) { return x * x; };`
限制	– 必须是字面类型 (literal type)。 – 函数体必须足够简单 (单个 `return` 语句或简单表达式)。 – C++17中，通常不能捕获任何变量（可以通过模板参数或立即调用Lambda表达式来间接实现）。 – C++20放宽了constexpr函数的限制，允许更复杂的控制流，但constexpr lambda表达式仍然存在一定的限制，特别是对于状态管理和副作用。	– 函数体不能包含循环 (除非在C++20及以后)。 – 不能使用`goto`语句或`try-catch`块。 – 无法直接捕获外部变量。
应用场景	– 编译期计算常量和表达式。 – 模板元编程。 – 编译期代码生成。 – 需要编译期优化和检查的场景。	– 计算数组大小。 – 生成查找表。 – 编译期验证配置值。

C++20 的变化

C++20 对 constexpr 函数做出了很大的改进，允许更复杂的控制流，例如循环和多个语句。但是，这些改进对 constexpr Lambda 表达式的影响相对较小。捕获仍然是一个限制，尽管可以通过模板或立即调用 Lambda 表达式来解决。

总结的总结

constexpr Lambda表达式是一个强大的工具，可以让你编写更高效、更安全的代码。虽然它有一些限制，但只要你理解了它的原理，就可以在很多场景下灵活运用它。记住关键点：字面类型、简单函数体、以及巧妙地“捕获”。希望今天的讲解对你有所帮助，以后可以愉快地玩转constexpr Lambda，写出更牛逼的代码！

发表回复 取消回复

发表回复取消回复