C++17 中的 constexpr 与即时编译：把常量函数变成编译时计算的艺术

作者

在 C++11 时，constexpr 的使用相对有限，主要用于声明常量表达式。随着 C++14 与 C++17 的到来，constexpr 函数的能力被大幅提升：现在它们可以包含循环、递归、甚至异常处理（C++20 以后）。这使得在编译期完成复杂计算成为可能，从而在运行时显著提升性能，减少内存占用，并提供更强的类型安全。本文将从语法演进、常见使用场景、性能收益以及实战案例四个方面，剖析 C++17 及以后的 constexpr 对编译时计算的影响。

1. constexpr 语法的演进

1.1 C++11 时代

在 C++11，constexpr 函数的定义极其简洁：

constexpr int square(int x) { return x * x; }

此时，constexpr 函数必须是单条返回语句，且参数和返回值必须是完整对象类型或内置类型。

1.2 C++14 的突破

C++14 允许在 constexpr 函数中使用 if、for、while、switch 等控制流语句，甚至可以使用递归调用：

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

此时，编译器会尝试在编译期展开递归调用，若递归深度过大仍可能导致编译时间增长。

1.3 C++17 的进一步提升

C++17 在 constexpr 上进一步松绑：现在可以使用 try / catch 语句，甚至 constexpr 成员变量可以是 std::string 等非 POD 类型。此时 constexpr 函数可以对任何可在编译期求值的表达式进行求值，包括调用其他非 constexpr 函数（只要它们本身可在编译期求值）。

2. 常见使用场景

2.1 预计算常量

许多算法需要预先生成表格，例如斐波那契数列、素数表或分形图像数据。利用 constexpr 可以在编译期完成这些预处理：

constexpr std::array<int, 10> fibonacci_table() {
    std::array<int, 10> arr{};
    arr[0] = 0; arr[1] = 1;
    for (int i = 2; i < 10; ++i) {
        arr[i] = arr[i-1] + arr[i-2];
    }
    return arr;
}
constexpr auto fib = fibonacci_table();

2.2 类型安全的元编程

使用 constexpr 与模板相结合，可实现强类型的编译期检查。例如，定义一个 constexpr 函数来判断某个数是否为质数，然后在模板中使用该函数决定是否实例化：

constexpr bool is_prime(int n) {
    if (n <= 1) return false;
    for (int i = 2; i*i <= n; ++i)
        if (n % i == 0) return false;
    return true;
}

template<int N>
struct PrimeTag {
    static_assert(is_prime(N), "N must be prime");
};

2.3 生成编译期字符串

C++20 引入了 consteval，但在 C++17 仍可以通过 constexpr 来拼接字符串常量，常用于生成错误信息、命名空间路径或其他编译时字符串：

constexpr const char* concat(const char* a, const char* b) {
    std::size_t len_a = std::strlen(a);
    std::size_t len_b = std::strlen(b);
    static char result[256];
    std::memcpy(result, a, len_a);
    std::memcpy(result + len_a, b, len_b);
    result[len_a + len_b] = '\0';
    return result;
}

3. 性能收益

  1. 运行时成本消除：所有 constexpr 计算在编译期完成，运行时无需再执行，减小了 CPU 负担。
  2. 更小的二进制文件：预计算的表格直接嵌入二进制，避免了运行时初始化代码。
  3. 改进缓存友好性：编译期生成的数据结构在程序加载时已就绪，减少了动态内存分配。
  4. 可验证的编译期错误：在编译期就捕获错误，避免了运行时崩溃，提高程序安全性。

4. 实战案例：编译期生成矩阵乘法的优化

4.1 问题描述

矩阵乘法是科学计算的核心之一。对于固定大小且常用的矩阵，我们希望在编译期生成一套针对该尺寸的乘法实现，以获得最快速度。传统做法是使用循环，编译器会进行循环展开，但手写展开代码往往更高效。

4.2 解决方案

利用 constexpr 递归生成矩阵乘法代码，构造一个 constexpr 函数返回预先展开的乘法结果。示例代码如下：

#include <array>
#include <iostream>

constexpr int N = 3;

template<int I, int J>
constexpr int compute_element(const std::array<std::array<int, N>, N>& A,
                              const std::array<std::array<int, N>, N>& B) {
    return (I < N && J < N)
           ? (I == N-1 && J == N-1)
             ? 0
             : (A[I][0] * B[0][J]
                + compute_element<I, J-1>(A, B))
           : 0;
}

template<int I>
constexpr std::array<int, N> compute_row(const std::array<std::array<int, N>, N>& A,
                                         const std::array<std::array<int, N>, N>& B) {
    return { compute_element<I, 0>(A, B), compute_element<I, 1>(A, B), compute_element<I, 2>(A, B) };
}

constexpr std::array<std::array<int, N>, N> matmul(const std::array<std::array<int, N>, N>& A,
                                                   const std::array<std::array<int, N>, N>& B) {
    return { compute_row <0>(A, B), compute_row<1>(A, B), compute_row<2>(A, B) };
}

int main() {
    constexpr std::array<std::array<int, N>, N> A = { std::array<int, N>{1,2,3},
                                                      std::array<int, N>{4,5,6},
                                                      std::array<int, N>{7,8,9} };

    constexpr std::array<std::array<int, N>, N> B = { std::array<int, N>{9,8,7},
                                                      std::array<int, N>{6,5,4},
                                                      std::array<int, N>{3,2,1} };

    constexpr auto C = matmul(A, B);
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            std::cout << C[i][j] << ' ';
        }
        std::cout << '\n';
    }
}

运行结果即为矩阵乘法的最终结果，所有计算均已在编译期完成。此实现可以根据需要自行扩展到更大尺寸的矩阵，并在编译期间自动展开，避免手工展开的繁琐。

5. 结语

C++17 对 constexpr 的增强，使得编译期计算从原本的简单数值演变为完整的程序控制流。通过预计算常量、强化类型安全、生成编译期字符串以及实现性能敏感的算法，开发者可以在不牺牲可维护性的前提下，显著提升程序的执行效率和可靠性。未来的 C++20、C++23 进一步完善 consteval、constinit 等关键字，将为编译期计算开启更广阔的可能性。让我们拥抱 constexpr 的力量，把编译器变成我们最可靠的计算引擎。

发表评论