5.5 — 常量表达式

在课程1.10 -- 表达式简介中，我们介绍了表达式。默认情况下，表达式在运行时求值。在某些情况下，它们必须如此。

std::cin >> x;
std::cout << 5 << '\n';

由于输入和输出无法在编译时执行，因此上述表达式需要在运行时求值。

在之前的课程5.4 -- as-if 规则和编译时优化中，我们讨论了 as-if 规则，以及编译器如何通过将工作从运行时转移到编译时来优化程序。根据 as-if 规则，编译器可以选择在运行时还是编译时评估某些表达式。

const double x { 1.2 };
const double y { 3.4 };
const double z { x + y }; // x + y may evaluate at runtime or compile-time

表达式 x + y 通常在运行时求值，但由于 x 和 y 的值在编译时已知，编译器可以选择执行编译时求值，并用编译时计算的值 4.6 初始化 z。

在其他一些情况下，C++ 语言要求表达式可以在编译时求值。例如，constexpr 变量需要一个可以在编译时求值的初始化器。

int main()
{
    constexpr int x { expr }; // Because variable x is constexpr, expr must be evaluatable at compile-time
}

在需要常量表达式但未提供的情况下，编译器将报错并停止编译。

我们将在下一课（5.6 -- Constexpr 变量）中讨论 constexpr 变量。

在本课中，我们将更深入地探讨 C++ 在编译时求值方面的能力，并研究 C++ 如何区分后一种情况与前两种情况。

编译时编程的优势

虽然 as-if 规则对于提高性能非常有用，但它让我们依赖于编译器的复杂性来实际确定什么可以在编译时求值。这意味着如果我们真的想在编译时执行一段代码，它可能行也可能不行。相同的代码在不同的平台，或使用不同的编译器，或使用不同的编译选项，或稍作修改，可能会产生不同的结果。由于 as-if 规则对我们是不可见的，我们无法从编译器那里获得关于它决定在编译时求值哪些代码以及原因的反馈。我们希望在编译时求值的代码甚至可能不符合条件（由于拼写错误或误解），我们可能永远不会知道。

为了改善这种情况，C++ 语言提供了明确指定我们希望在编译时执行的代码部分的方法。使用导致编译时求值的语言特性称为编译时编程。

这些特性可以在许多方面帮助改进软件

• 性能：编译时求值使我们的程序更小更快。我们能确保在编译时求值的代码越多，我们看到的性能优势就越大。
• 通用性：我们总能将此类代码用于需要编译时值的地方。依赖 as-if 规则在编译时求值的代码不能用于此类地方（即使编译器选择在编译时求值该代码）——之所以做出此决定，是为了让今天编译的代码不会在明天编译器决定以不同方式优化时停止编译。
• 可预测性：如果编译器确定代码无法在编译时执行，我们可以让它停止编译（而不是默默地选择让代码在运行时求值）。这使我们能够确保我们真正希望在编译时执行的代码部分能够执行。
• 质量：我们可以让编译器在编译时可靠地检测某些类型的编程错误，并在遇到这些错误时停止构建。这比在运行时尝试检测和优雅地处理相同的错误要有效得多。
• 质量：也许最重要的是，编译时不允许未定义行为。如果我们在编译时做了导致未定义行为的事情，编译器应该停止构建并要求我们修复它。请注意，这对编译器来说是一个难题，它们可能无法捕获所有情况。

总而言之，编译时求值使我们能够编写性能更高、质量更好（更安全、bug 更少）的程序！因此，虽然编译时求值确实增加了语言的一些额外复杂性，但其好处可能是巨大的。

以下 C++ 特性是编译时编程最基础的

• Constexpr 变量（将在即将到来的课程5.6 -- Constexpr 变量中讨论）。
• Constexpr 函数（将在即将到来的课程F.1 -- Constexpr 函数中讨论）。
• 模板（在课程11.6 -- 函数模板中介绍）。
• static_assert（在课程9.6 -- 断言和 static_assert中讨论）。

所有这些特性都有一个共同点：它们都使用常量表达式。

常量表达式

也许令人惊讶的是，C++ 标准几乎没有提及“编译时”。相反，标准定义了一个“常量表达式”，它是一个必须在编译时可求值的表达式，并附带确定编译器应如何处理这些表达式的规则。常量表达式构成了 C++ 中编译时求值的骨干。

在课程1.10 -- 表达式简介中，我们将表达式定义为“字面量、变量、运算符和函数调用的非空序列”。常量表达式是字面量、常量变量、运算符和函数调用的非空序列，所有这些都必须在编译时可求值。关键区别在于，在常量表达式中，表达式的每个部分都必须在编译时可求值。

不是常量表达式的表达式通常称为非常量表达式，并且可以非正式地称为运行时表达式（因为此类表达式通常在运行时求值）。

常量表达式中可以包含什么？

最常见的是，常量表达式包含以下内容

• 字面量（例如 '5', '1.2'）
• 大多数带有常量表达式操作符的运算符（例如 3 + 4, 2 * sizeof(int)）。
• 带有常量表达式初始化器的 const 整型变量（例如 const int x { 5 };）。这是一个历史例外——在现代 C++ 中，constexpr 变量更受青睐。
• Constexpr 变量（将在即将到来的课程5.6 -- Constexpr 变量中讨论）。
• 带有常量表达式参数的 constexpr 函数调用（参见F.1 -- Constexpr 函数）。

常量表达式和非常量表达式的示例

在以下程序中，我们查看了一些表达式语句，并指出每个表达式是常量表达式还是运行时表达式

#include <iostream>

int getNumber()
{
    std::cout << "Enter a number: ";
    int y{};
    std::cin >> y; // can only execute at runtime

    return y;      // this return expression is a runtime expression
}

// The return value of a non-constexpr function is a runtime expression
// even when the return expression is a constant expression
int five()
{
    return 5;      // this return expression is a constant expression
}

int main()
{
    // Literals can be used in constant expressions
    5;                           // constant expression            
    1.2;                         // constant expression
    "Hello world!";              // constant expression

    // Most operators that have constant expression operands can be used in constant expressions
    5 + 6;                       // constant expression
    1.2 * 3.4;                   // constant expression
    8 - 5.6;                     // constant expression (even though operands have different types)
    sizeof(int) + 1;             // constant expression (sizeof can be determined at compile-time)

    // The return values of non-constexpr functions can only be used in runtime expressions
    getNumber();                 // runtime expression
    five();                      // runtime expression (even though the return expression is a constant expression)

    // Operators without constant expression operands can only be used in runtime expressions
    std::cout << 5;              // runtime expression (std::cout isn't a constant expression operand)

    return 0;
}

在以下代码片段中，我们定义了一些变量，并指出它们是否可以在常量表达式中使用

    // Const integral variables with a constant expression initializer can be used in constant expressions:
    const int a { 5 };           // a is usable in constant expressions
    const int b { a };           // b is usable in constant expressions (a is a constant expression per the prior statement)
    const long c { a + 2 };      // c is usable in constant expressions (operator+ has constant expression operands)

    // Other variables cannot be used in constant expressions (even when they have a constant expression initializer):
    int d { 5 };                 // d is not usable in constant expressions (d is non-const)
    const int e { d };           // e is not usable in constant expressions (initializer is not a constant expression)
    const double f { 1.2 };      // f is not usable in constant expressions (not a const integral variable)

常量表达式在编译时求值时

由于常量表达式总是能够在编译时求值，您可能已经假定常量表达式将始终在编译时求值。然而，这与直觉相反，情况并非如此。

编译器只在**要求**常量表达式的上下文中**要求**在编译时求值常量表达式。

在不要求常量表达式的上下文中，编译器可以选择在编译时还是在运行时求值常量表达式。

const int x { 3 + 4 }; // constant expression 3 + 4 must be evaluated at compile-time
int y { 3 + 4 };       // constant expression 3 + 4 may be evaluated at compile-time or runtime

变量 x 的类型为 const int，并带有常量表达式初始化器，x 可用于常量表达式。其初始化器必须在编译时求值（否则 x 的值在编译时将未知，并且 x 将无法用于常量表达式）。另一方面，变量 y 是非 const 的，因此 y 无法用于常量表达式。即使其初始化器是常量表达式，编译器也可以决定在编译时或运行时求值初始化器。

即使不需要这样做，现代编译器在启用优化时通常会在编译时求值常量表达式。

为什么编译时表达式必须是常量 可选

您可能想知道为什么编译时表达式只能包含常量对象（以及可以在编译时求值为常量的运算符和函数）。

考虑以下程序

#include <iostream>

int main()
{
    int x { 5 };
    // x is known to the compiler at this point

    std::cin >> x; // read in value of x from user
    // x is no longer known to the compiler

    return 0;
}

首先，x 初始化值为 5。此时 x 的值对编译器是已知的。但随后 x 被用户赋值。编译器无法在编译时知道用户会提供什么值，因此从这一点开始，x 的值对编译器是未知的。因此，表达式 x 并非总是能在编译时求值，违反了此类表达式必须始终能在编译时求值的要求。

因为常量的值不能改变，所以一个其初始化器可以在编译时求值的常量变量，其值总是可以在编译时已知。这使得事情变得简单。

虽然语言设计者可以将编译时表达式定义为所有值在编译时当前已知的表达式（而不是一个必须始终能够在编译时求值的表达式），但这会给编译器增加显著的复杂性（因为编译器现在将负责确定每个变量何时可能更改为编译时未知的值）。添加一行代码（例如 std::cin >> x）可能会在程序的其他地方破坏程序（如果 x 在任何需要编译时已知值的上下文中被使用）。

小测验时间

问题 #1

对于每个语句，识别

• 初始化器是常量表达式还是非常量表达式。
• 变量是常量表达式还是非常量表达式。

a)

    char a { 'q' };

显示答案

b)

    const int b { 0 };

显示答案

c)

    const double c { 5.0 };

显示答案

d)

    const int d { a * 2 }; // a defined as char a { 'q' };

显示答案

e)

    int e { c + 1.0 }; // c defined as const double c { 5.0 };

显示答案

f)

    const int f { d * 2 }; // d defined as const int d { 0 };

显示答案

g)

    const int g { getNumber() }; // getNumber returns an int by value

显示答案

h)
额外加分

    const int h{};

显示答案