突破编程_C++_C++14新特性（constexpr 常量表达式）

1 C++11 constexpr 回顾

1.1 constexpr 基本概念

C++11 中的 constexpr 是一个非常重要的关键字，它主要用于定义常量表达式。常量表达式是指在编译时就能确定其值的表达式，且这个值在程序的整个生命周期中都不会改变。使用 constexpr 可以使得这些表达式在编译期进行计算，而不是在运行时，从而提高了程序的性能。

以下是 constexpr 的基础概念：

• 编译时计算：constexpr 允许编译器在编译时进行计算，而不是在运行时。这有助于减少程序运行时的计算负担，提高性能。
• 定义常量：constexpr 可以用来定义常量，这些常量的值在编译时就能确定，并且在程序的整个生命周期中保持不变。与 const 不同，constexpr 要求变量的值必须是常量表达式，这意味着变量的初始化必须是可以在编译时计算出的表达式。
• 修饰函数：除了修饰变量，C++11 还允许定义 constexpr 函数。这些函数必须在编译时就能得出结果，并且它们的参数也必须是常量表达式。这样，constexpr 函数就可以用在需要常量表达式的上下文中，比如数组的大小或者模板参数。

constexpr 的出现使得 C++ 在编译时优化方面有了更大的提升，也使得程序员能够写出更加高效和安全的代码。然而，需要注意的是，虽然 constexpr 提供了很多便利，但它也有一定的使用限制。例如，constexpr 变量的初始化必须是常量表达式，这限制了它的使用范围。此外，并非所有的函数都能被声明为 constexpr，只有那些满足特定条件的函数才能使用 constexpr 修饰。

1.2 constexpr 在 C++11 中的限制

（1）变量限制：

• 使用 constexpr 修饰的变量必须经过初始化，且其初始值必须是一个常量表达式。常量表达式是在编译时就能确定其值的表达式，不包含任何运行时的信息或行为。
• 并非所有类型的变量都能被声明为 constexpr。例如，自定义类、IO 库和string类型由于无法在编译时确定其值，因此不能被定义为 constexpr。而算数类型、引用和指针（但其初始值受到严格限制）以及某些类属于字面值类型，可以被定义为 constexpr。

（2）函数限制：

• 不是所有的函数都能被 constexpr 修饰。constexpr 函数必须满足一些特定的条件，才能在编译时计算出结果。
• constexpr 函数体内只能包含 using 指令、typedef 语句、static_assert 断言、空语句和一条 return 返回语句。函数体内不能包含定义新变量的语句或其他运行时语句，只能包含编译期语句。
• constexpr 函数返回的不一定是常量表达式。虽然函数的返回结果必须在编译时确定，但这并不意味着返回的结果本身在程序的后续使用中不能被修改（除非它被声明为 constexpr 变量）。

1.3 constexpr 在 C++11 中的应用示例

以下是 C++11 中 constexpr 的简单应用示例，包括 constexpr 变量和 constexpr 函数的用法：

（1）constexpr变量

#include   
  
int main() {  
    // 使用constexpr定义常量表达式变量  
    constexpr int a = 5;  
    constexpr int b = a * 2; // 使用前一个constexpr变量进行计算  
  
    // constexpr变量可以在这里直接初始化数组的大小  
    constexpr int arraySize = 10;  
    int myArray[arraySize];  
  
    // 输出变量值  
    std::cout << "a: " << a << std::endl;  
    std::cout << "b: " << b << std::endl;  
  
    return 0;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

上面代码的输出为：

a: 5
b: 10
1
2

在这个例子中，a 和 b 都是 constexpr 变量，它们的值在编译时就已经确定。arraySize 也是 constexpr 变量，它用于初始化数组 myArray 的大小。

（2）constexpr函数

#include   
  
// 定义一个constexpr函数  
constexpr int add(int x, int y) {  
    return x + y;  
}  
  
int main() {  
    // 使用constexpr函数初始化constexpr变量  
    constexpr int sum = add(2, 3);  
  
    // 输出结果  
    std::cout << "Sum: " << sum << std::endl;  
  
    return 0;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

上面代码的输出为：

Sum: 5
1

在这个例子中，add 函数是一个 constexpr 函数，它接收两个整数参数并返回它们的和。这个函数可以在编译时计算其返回值，因此它可以用来初始化 constexpr 变量 sum。

2 C++14 constexpr 的新特性

2.1 constexpr 函数改进

（1）返回类型推断

在 C++11 中，constexpr 函数需要显式地指定返回类型。然而，在 C++14 中，可以利用返回类型推断（Return Type Deduction，RTD）来自动推断 constexpr 函数的返回类型。这一特性通常与 auto 关键字一起使用，使得函数编写更加简洁和直观。

C++11 示例（需要显式指定返回类型）：

constexpr int add(int a, int b) {  
    return a + b;  
}
1
2
3

C++14 示例（利用返回类型推断）：

constexpr auto add(int a, int b) -> decltype(a + b) {  
    return a + b;  
}
1
2
3

（2）允许在函数体中有更多种类的语句

C++11 对 constexpr 函数的限制比较严格，只允许函数体中包含一些非常简单的语句，如 return 语句、常量表达式等。然而，在 C++14 中，这些限制得到了放宽，允许在 constexpr 函数体中使用更多种类的语句。

具体来说，C++14 允许在 constexpr 函数体中使用以下类型的语句：

• 控制流语句：如 if、switch 等条件语句，以及 for、while 等循环语句。这些语句的使用受到一定限制，例如循环条件必须是常量表达式，并且循环体内部不能有任何非常量表达式。
• 局部变量声明：可以在 constexpr 函数内部声明局部变量，但这些变量必须是常量表达式，且其初始化也必须是常量表达式。
• 其他语句：一些在 C++11 中不被允许的语句，如空语句、类型别名声明等，在 C++14 中也可以在 constexpr 函数体中使用。

C++14 示例（包含控制流语句）：

constexpr int fibonacci(int n) {  
    if (n <= 1) {  
        return n;  
    } else {  
        return fibonacci(n - 1) + fibonacci(n - 2);  
    }  
}
1
2
3
4
5
6
7

在这个例子中，fibonacci 函数是一个递归函数，它使用了 if 语句来根据 n 的值选择不同的计算路径。由于 C++14 放宽了对 constexpr 函数体的限制，这样的递归函数现在也可以被声明为 constexpr。

需要注意的是，尽管 C++14 放宽了对 constexpr 函数体的限制，但这些函数仍然必须满足常量表达式的要求。也就是说，函数的执行路径和所有变量的值必须在编译时就能确定。因此，在使用控制流语句和局部变量时，必须确保它们的使用符合这些要求。

2.2 constexpr 变量的改进

C++11 中，constexpr 变量的初始化必须是一个常量表达式，这限制了初始化表达式的复杂性。然而，在 C++14 中，只要这些表达式在编译时能够计算出结果，就可以用于初始化 constexpr 变量。

下面是一些 C++14 中 constexpr 变量初始化使用更复杂表达式的示例：

（1）示例1：使用函数调用初始化 constexpr 变量

constexpr int add(int a, int b) {  
    return a + b;  
}  
  
int main() {  
    constexpr int sum = add(2, 3); // 使用函数调用来初始化constexpr变量  
    std::cout << "Sum: " << sum << std::endl;  
    return 0;  
}
1
2
3
4
5
6
7
8
9

上面代码的输出为：

Sum: 5
1

在 C++14 中，add 函数是一个 constexpr 函数，因此可以在编译时计算出结果。这使得我们可以使用 add(2, 3) 这个函数调用作为 constexpr 变量 sum 的初始化表达式。

（2）示例2：使用条件运算符初始化 constexpr 变量

constexpr bool isPositive(int n) {  
    return n > 0;  
}  
  
int main() {  
    constexpr bool isPositiveNumber = isPositive(5) ? true : false; // 使用条件运算符初始化constexpr变量  
    std::cout << "Is positive: " << std::boolalpha << isPositiveNumber << std::endl;  
    return 0;  
}
1
2
3
4
5
6
7
8
9

上面代码的输出为：

Is positive: true
1

在这个例子中，isPositive 函数用于检查一个整数是否为正数。在main函数中，我们使用条件运算符来根据 isPositive(5) 的结果初始化 constexpr 变量 isPositiveNumber。由于 isPositive 函数是一个 constexpr 函数，并且条件运算符的结果在编译时也是常量，因此这是有效的。

（3）示例3：使用复杂的算术表达式初始化 constexpr 变量

constexpr int complexCalculation() {  
    int a = 2 * 3 + 5;  
    int b = a * (a - 1);  
    return b / 2;  
}  
  
int main() {  
    constexpr int result = complexCalculation(); // 使用复杂的算术表达式初始化constexpr变量  
    std::cout << "Result: " << result << std::endl;  
    return 0;  
}
1
2
3
4
5
6
7
8
9
10
11

上面代码的输出为：

Result: 55
1

在这个例子中，complexCalculation 函数执行了一系列复杂的算术运算。由于这些运算在编译时都是可计算的，因此我们可以安全地使用 complexCalculation() 作为 constexpr 变量 result 的初始化表达式。

2.3 constexpr lambda 表达式

C++14 支持了 constexpr lambda 表达式。这意味着我们可以创建在编译时就能确定结果的 lambda 表达式，这些表达式可以在需要常量表达式的上下文中使用，比如模板元编程、数组大小确定等。

（1）constexpr lambda 的基本特性

• 编译时计算：constexpr lambda 允许在编译时进行计算，确保结果是常量。
• 无状态：constexpr lambda 不能有捕获子句（即不能有 [=] 或 [&]），因为捕获会导致 lambda 有状态，而 constexpr 要求其结果是完全确定的，不受任何运行时状态的影响。
• 返回类型推断：constexpr lambda 的返回类型通常可以通过返回语句自动推断。

下面是一个简单的示例，演示了如何使用 constexpr lambda：

#include   
  
int main() {  
    // 定义一个 constexpr lambda  
    constexpr auto add = [](int a, int b) { return a + b; };  
  
    // 使用 constexpr lambda 在编译时计算  
    constexpr int sum = add(2, 3);  
  
    // 输出结果  
    std::cout << "Sum at compile time: " << sum << std::endl;  
  
    // 注意：由于 constexpr lambda 不能有捕获子句，以下代码会报错  
    // constexpr auto captureLambda = [x = 5](int y) { return x + y; };  
  
    return 0;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

上面代码的输出为：

Sum at compile time: 5
1

这个例子定义了一个 constexpr lambda add，它接受两个整数参数并返回它们的和。然后，在编译时使用这个 lambda 来计算 2 + 3 的结果，并将结果存储在 constexpr 变量 sum 中。这样，sum 的值在编译时就已经确定了。

（2）constexpr lambda 的限制

尽管 constexpr lambda 提供了在编译时进行计算的能力，但它们仍然有一些限制：

• 无捕获：如上所述，constexpr lambda 不能有任何捕获子句。
• 简单性：为了能够在编译时计算，constexpr lambda 通常需要保持简单，避免复杂的逻辑或运行时行为。
• 返回类型推断：虽然大多数情况下返回类型可以自动推断，但在某些复杂的场景下可能需要显式指定。

2.4 constexpr 与模板的结合

在 C++14 中，constexpr 与模板的结合为编程提供了更为强大的工具，使得在编译时能够执行复杂的元编程操作，并生成高效、类型安全的代码。constexpr 允许你在编译时计算常量表达式，而模板则提供了在编译时根据类型或值生成代码的能力。当这两者结合使用时，它们能够产生高度优化和类型安全的代码，且这些代码通常在运行时没有额外的性能开销。

（1）constexpr 与函数模板

constexpr 可以与函数模板结合使用，以在编译时根据不同类型计算常量表达式。这样，可以为多种类型定义通用的常量计算逻辑，而无需为每个类型单独编写代码。

下面是一个简单的示例，演示了如何使用 constexpr 函数模板计算不同类型的平方：

template<typename T>  
constexpr T square(T x) {  
    return x * x;  
}  
  
int main() {  
    constexpr int intSquare = square(5);  // 计算 int 类型的平方  
    constexpr double doubleSquare = square(3.14);  // 计算 double 类型的平方  
  
    // 输出结果  
    std::cout << "Int square: " << intSquare << std::endl;  
    std::cout << "Double square: " << doubleSquare << std::endl;  
  
    return 0;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

上面代码的输出为：

Int square: 25
Double square: 9.8596
1
2

在这个例子中，square 是一个 constexpr 函数模板，它接受一个类型参数 T 和一个值参数 x。然后，它返回 x 的平方。由于 square 是 constexpr 的，因此可以在编译时计算 intSquare 和 doubleSquare 的值。

（2）constexpr 与类模板

constexpr 同样可以与类模板结合使用，允许在编译时创建常量类对象，并初始化其常量成员。这在需要类型特定常量的元编程场景中非常有用。

下面是一个使用 constexpr 类模板的示例：

template<typename T>  
struct ConstantValue {  
    constexpr static T value = T();  // 初始化一个类型特定的默认值  
};  
  
int main() {  
    constexpr int intValue = ConstantValue<int>::value;  // int 类型的默认值  
    constexpr double doubleValue = ConstantValue<double>::value;  // double 类型的默认值  
  
    // 输出结果  
    std::cout << "Int value: " << intValue << std::endl;  // 通常输出 0  
    std::cout << "Double value: " << doubleValue << std::endl;  // 通常输出 0.0  
  
    return 0;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

上面代码的输出为：

Int value: 0
Double value: 0
1
2

在这个例子中，ConstantValue 是一个类模板，它有一个 constexpr static 成员 value，该成员在编译时被初始化为类型 T 的默认值。这样，我们就可以为不同的类型创建常量值，并在编译时使用它们。

（3）constexpr 与模板元编程

模板元编程是一种在编译时执行复杂计算的技术，它依赖于模板特化和递归模板展开。当与 constexpr 结合时，可以在编译时执行更为复杂的计算，而无需牺牲运行时的性能。

例如，可以使用 constexpr 函数模板和递归模板元编程来计算阶乘：

template<std::size_t N>  
constexpr std::size_t factorial() {  
    return N * factorial<N - 1>();  
}  
  
template<>  
constexpr std::size_t factorial<0>() {  
    return 1;  
}  
  
int main() {  
    constexpr std::size_t fiveFactorial = factorial<5>();  // 编译时计算 5 的阶乘  
  
    // 输出结果  
    std::cout << "5 factorial: " << fiveFactorial << std::endl;  // 输出 120  
  
    return 0;  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

上面代码的输出为：

5 factorial: 120
1

在这个例子中，factorial 是一个模板特化的函数，它在编译时递归地计算给定数字的阶乘。通过特化 factorial<0>，我们为递归提供了一个基准情况。这样，我们就可以在编译时计算 fiveFactorial 的值，而无需在运行时执行任何递归计算。