Constant expressions

定义可在编译时求值的 表达式 。

此类表达式可用作常量模板参数、数组大小，以及其他需要常量表达式的场景，例如

int n = 1;
std::array<int, n> a1;  // 错误：“n”不是常量表达式
const int cn = 2;
std::array<int, cn> a2; // 正确：“cn”是常量表达式

定义

在判断表达式是否为常量表达式时，假定 复制消除 不会被执行。

C++98 关于常量表达式的定义完全折叠在隐藏框内。以下描述适用于 C++11 及后续 C++ 版本。

字面类型

以下类型统称为 字面类型 ：

• 可能带有 cv 限定符的 void
• 标量类型
• 引用类型
• 字面类型的 数组
• 可能带有 cv 限定符的类类型，且满足以下所有条件：

• 它拥有 平凡析构函数 (C++20 前) constexpr 析构函数 (C++20 起) 。
• 其所有非静态非变体数据成员和基类均为非易失性字面类型。
• 它是以下类型之一：

• 满足以下条件之一的 聚合 联合类型：

• 没有 变体成员
• 至少有一个非易失性字面类型的变体成员

• 非联合聚合类型，且其每个 匿名联合 成员满足以下条件之一：

• 没有变体成员
• 至少有一个非易失性字面类型的变体成员

• 具有至少一个非拷贝/移动构造函数的 constexpr 构造函数（模板）

只有字面类型的对象才能在常量表达式中创建。

核心常量表达式

一个 核心常量表达式 是指其求值 不会 涉及以下任一语言结构的表达式：

1. 调用未声明为 constexpr 的函数（或构造函数）的函数调用表达式

   constexpr int n = std::numeric_limits<int>::max(); // 正确：max() 是 constexpr
   constexpr int m = std::time(nullptr); // 错误：std::time() 不是 constexpr

2. 调用已声明但未定义的 constexpr 函数的函数调用
3. 调用 constexpr 函数/构造函数模板实例化，但该实例化不满足 constexpr 函数/构造函数 要求
4. 调用 constexpr 虚函数，且该调用作用于动态类型为 constexpr-未知 的对象
5. 超出实现定义限制的表达式
6. 求值会导致任何形式的核心语言 未定义 或错误 (C++26 起) 行为的表达式，除非是由 标准属性 引入的潜在未定义行为

   constexpr double d1 = 2.0 / 1.0; // 正确
   constexpr double d2 = 2.0 / 0.0; // 错误：未定义
   constexpr int n = std::numeric_limits<int>::max() + 1; // 错误：溢出
   int x, y, z[30];
   constexpr auto e1 = &y - &x;        // 错误：未定义
   constexpr auto e2 = &z[20] - &z[3]; // 正确
   constexpr std::bitset<2> a; 
   constexpr bool b = a[2]; // 未定义行为，但未指定是否会被检测

7. (C++17 前) lambda 表达式
8. 左值到右值的 隐式转换 ，除非应用于...
   1. 类型为（可能 cv 限定的） std::nullptr_t 的泛左值
   2. 非易失性字面类型的泛左值，且其指代的对象 可在常量表达式中使用

      int main()
      {
          const std::size_t tabsize = 50;
          int tab[tabsize]; // 正确：tabsize 是常量表达式
                            // 因为 tabsize 可在常量表达式中使用
                            // 因为它具有 const 限定的整型类型，且
                            // 其初始化器是常量初始化器
          std::size_t n = 50;
          const std::size_t sz = n;
          int tab2[sz]; // 错误：sz 不是常量表达式
                        // 因为 sz 不可在常量表达式中使用
                        // 因为其初始化器不是常量初始化器
      }

   3. 非易失性字面类型的泛左值，且其引用的非易失性对象的生存期始于该表达式的求值过程中
9. 应用于 联合体 或其子对象的非活跃成员的左值到右值 隐式转换 或修改（即使其与活跃成员共享公共初始序列）
10. 对 值不确定 的对象进行左值到右值隐式转换
11. 调用联合体的隐式复制/移动构造函数/赋值运算符，且该联合体的活跃成员（如果有）为 mutable，且其生存期始于该表达式求值之外
12. (C++20 前) 会改变联合体活跃成员的赋值表达式
13. 从 指向 void 的指针 到指向对象类型 T* 的转换 ，除非该指针持有空指针值或指向类型与 T 相似 的对象 (C++26 起)
14. dynamic_cast ，且其操作数是引用动态类型为 constexpr-未知 的对象的泛左值 (C++20 起)
15. reinterpret_cast
16. (C++20 前) 伪析构函数调用
17. (C++14 前) 自增或自减运算符
18. (C++14 起) 修改对象，除非该对象具有非易失性字面类型且其生存期始于该表达式的求值过程中

    constexpr int incr(int& n)
    {
        return ++n;
    }
    constexpr int g(int k)
    {
        constexpr int x = incr(k); // 错误：incr(k) 不是核心常量
                                   // 表达式，因为 k 的生存期
                                   // 始于表达式 incr(k) 之外
        return x;
    }
    constexpr int h(int k)
    {
        int x = incr(k); // 正确：x 不需要用核心常量表达式初始化
                         //
        return x;
    }
    constexpr int y = h(1); // 正确：用值 2 初始化 y
                            // h(1) 是核心常量表达式，因为
                            // k 的生存期始于表达式 h(1) 内部

19. (C++20 起) 对生存期未始于该表达式求值过程中的对象进行析构函数调用或伪析构函数调用
20. 应用于多态类型的泛左值的 typeid 表达式 ，且该泛左值引用动态类型为 constexpr-未知 的对象 (C++20 起)
21. new 表达式 ，除非满足以下条件之一： (C++20 起)

    选择的 分配函数 是可替换的全局分配函数，且分配的存储在该表达式的求值过程中被释放。	(C++20 起)
    选择的分配函数是具有分配类型 T 的非分配形式，且 placement 参数满足以下所有条件： 它指向： 类型与 T 相似的对象，如果 T 不是数组类型，或 类型与 T 相似的对象的首元素，如果 T 是数组类型。 它指向的存储的生存期始于该表达式的求值过程中。 </ul

额外要求

即使表达式 E 未评估上述任何情况，若对 E 的求值会导致 运行时未定义行为 ，则 E 是否为核心常量表达式由实现定义。

即使表达式 E 未计算上述任何内容，若计算 E 将计算以下任何操作，则 E 是否为核心常量表达式是未指定的：

• 在 标准库 中具有未定义行为的操作。
• 对 va_start 宏的调用。

为判断表达式是否为核心常量表达式，若 T 为字面类型，则忽略 std:: allocator < T > 成员函数体的求值过程。

为判断表达式是否为核心常量表达式，对 联合体 的平凡复制/移动构造函数或复制/移动赋值运算符的调用，其求值过程被视为复制/移动该联合体的活跃成员（若存在）。

在将表达式作为核心常量表达式求值期间，所有引用生命周期始于该表达式求值之外的对象的标识符表达式及 * this 的使用，均被视为引用该对象或引用的特定实例，该实例及其所有子对象（包括所有联合体成员）的生命周期需涵盖整个常量求值过程。

• 对于此类 不可在常量表达式中使用的 (C++20 起) 对象，该对象的动态类型为 constexpr-unknown 。
• 对于此类 不可在常量表达式中使用的 (C++20 起) 引用，该引用被视为绑定到被引用类型的一个未指定对象，该对象及其所有子对象的生存期涵盖整个常量求值过程，且其动态类型为 constexpr-unknown。

整型常量表达式

整型常量表达式 是指整型或无作用域枚举类型的表达式，该表达式被隐式转换为纯右值，且转换后的表达式为核心常量表达式。

当需要整型常量表达式的地方使用了类类型的表达式时，该表达式会被 上下文隐式转换 为整型或无作用域枚举类型。

转换后的常量表达式

类型 T 的 转换后常量表达式 是指一个被 隐式转换 为类型 T 的表达式，其中被转换的表达式是常量表达式，且隐式转换序列仅包含：

• constexpr 用户定义转换
• 左值到右值转换
• 整型提升
• 非窄化 整型转换
• 浮点提升
• 非窄化 浮点转换

如果发生任何 引用绑定 ，它只能是 直接绑定 。

以下上下文需要转换后的常量表达式：

• case 标签 的 常量表达式
• 当底层类型固定时的 枚举项初始化器
• 整型与枚举 (C++17 前) 常量 模板参数

一个 上下文转换为 bool 类型的常量表达式 是指： 被上下文转换为 bool 的表达式，其中被转换的表达式是常量表达式，且转换序列仅包含上述转换规则。

以下上下文需要类型为 bool 的上下文转换常量表达式：

• noexcept 规范

常量求值所需的函数与变量

以下表达式或转换属于 潜在常量求值 ：

• 明显常量求值表达式
• 潜在求值表达式
• 花括号初始化列表 的直接子表达式（可能需要常量求值以确定 转换是否属于窄化转换 ）
• 出现在 模板实体 内的取址表达式（可能需要常量求值以确定此类表达式是否属于 值依赖表达式 ）
• 上述表达式的子表达式，且不属于嵌套 未求值操作数 的子表达式

一个函数在以下情况下 需要用于常量求值 ：如果它是 constexpr 函数，且被可能进行常量求值的表达式 命名 。

一个变量在以下情况下 需要用于常量求值 ：如果它是constexpr变量，或者是非volatile const限定的整型类型或引用类型，并且表示该变量的 标识符表达式 可能被常量求值。

默认函数的定义以及 函数模板 特化 或 变量模板 特化 (since C++14) 的实例化会在函数 或变量 (since C++14) 被常量求值需要时触发。

常量子表达式

一个 常量子表达式 是指这样的表达式：作为表达式 e 的子表达式进行求值时，不会阻碍 e 成为 核心常量表达式 ，其中 e 不属于以下任一表达式：

• throw 表达式

• 赋值表达式
• 逗号表达式

注释

示例

缺陷报告

下列行为变更缺陷报告被追溯应用于先前发布的C++标准。

参见