Constant expressions

定义一个可在编译时求值的 expression （表达式）。

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

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

定义

在确定表达式是否为常量表达式时， copy elision 被假定为不会执行。

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

字面类型

以下类型统称为 literal types ：

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

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

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

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

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

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

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

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

核心常量表达式

core constant expression 是指其求值过程 不会 涉及以下任一语言结构的表达式：

1. a function call expression that calls a function (or a constructor) that is not declared constexpr

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

2. a function call to a constexpr function which is declared, but not defined
3. a function call to a constexpr function/constructor template instantiation where the instantiation fails to satisfy constexpr 函数/构造函数 requirements.
4. a function call to a constexpr virtual function, invoked on an object whose dynamic type is constexpr-unknown
5. an expression that would exceed the implementation-defined limits
6. an expression whose evaluation leads to any form of core language undefined 或错误的 (始于 C++26) behavior, except for any potential undefined behavior introduced by 标准属性 .

   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 前) a lambda 表达式
8. an lvalue-to-rvalue 隐式转换 unless applied to...
   1. 类型为（可能带有 cv 限定符） std::nullptr_t 的泛左值
   2. 指定了 可在常量表达式中使用 的对象的非易失性字面类型的泛左值

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

   3. 引用其生存期始于该表达式求值内的非易失性对象的非易失性字面类型的泛左值
9. an lvalue-to-rvalue 隐式转换 or modification applied to a non-active member of a union or its subobject (even if it shares a common initial sequence with the active member)
10. an lvalue-to-rvalue implicit conversion on an object 其值是不确定的
11. an invocation of implicit copy/move constructor/assignment for a union whose active member is mutable (if any), with lifetime beginning outside the evaluation of this expression
12. (直至 C++20) an assignment expression that would change the active member of a union
13. conversion from 指向 void 的指针 to a pointer-to-object type T* 除非该指针持有空指针值或指向其类型与 similar 于 T 的对象 (C++26 起)
14. dynamic_cast 其操作数为引用动态类型为constexpr未知对象的glvalue (C++20 起)
15. reinterpret_cast
16. (直至 C++20) pseudo-destructor call
17. (C++14 前) an increment or a decrement operator
18. (自 C++14 起) modification of an object, unless the object has non-volatile literal type and its lifetime began within the evaluation of the expression

    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 起) a destructor call or pseudo destructor call for an object whose lifetime did not begin within the evaluation of this expression
20. a typeid expression applied to a glvalue of polymorphic type 且该泛左值所引用的对象具有常量表达式未知的动态类型 (C++20 起)
21. a new expression ，除非满足以下条件之一： (C++20 起)

    所选的 allocation function 是可替换的全局分配函数，且分配的存储空间在此表达式求值期间被释放。	(since C++20)
    所选的分配函数是具有分配类型 T 的非分配形式，且 placement 参数满足以下所有条件： 它指向： 一个类型与 T 相似的对象（若 T 不是数组类型），或 与 T 相似类型的对象的首元素（若 T 是数组类型）。 它指向的存储空间其生存期在此表达式求值期间开始。	(since C++26)

22. a delete 表达式 ，除非它释放了在此表达式求值过程中分配的存储区域 (C++20 起)
23. (自 C++20 起) Coroutines: an await表达式 or a yield表达式
24. (自 C++20 起) a 三路比较 when the result is unspecified
25. an equality or relational operator whose result is unspecified
26. (C++14 前) an assignment or a compound assignment operator
27. (C++26 前) throw 表达式
28. (C++26 起) 异常对象的构造，除非该异常对象及其通过调用 std::current_exception 或 std::rethrow_exception 创建的所有隐式副本都在该表达式求值期间被销毁

    constexpr void check(int i)
    {
        if (i < 0)
            throw i;
    }
    constexpr bool is_ok(int i)
    {
        try {
            check(i);
        } catch (...) {
            return false;
        }
        return true;
    }
    constexpr bool always_throw()
    {
        throw 12;
        return true;
    }
    static_assert(is_ok(5)); // 正确
    static_assert(!is_ok(-1)); // C++26 起正确
    static_assert(always_throw()); // 错误：未捕获异常

29. asm 声明
30. 调用 va_arg 宏
31. goto 语句
32. dynamic_cast 或 typeid 表达式 或 new 表达式 (C++26 起) 会抛出异常的情况 且异常类型定义不可达时 (C++26 起)
33. lambda 表达式内对 this 或外部变量的引用，若该引用构成 ODR 使用

    void g()
    {
        const int n = 0;
        constexpr int j = *&n; // 正确：在 lambda 表达式外
        [=]
        {
            constexpr int i = n;   // 正确：'n' 未在此处被 ODR 使用且未被捕获
            constexpr int j = *&n; // 错误：'&n' 将构成对 'n' 的 ODR 使用
        };
    }

    注意：若 ODR 使用发生在对闭包的函数调用中，则不会引用 this 或外部变量，因为此时访问的是闭包的数据成员 // 正确：'v' 和 'm' 被 ODR 使用但未在嵌套 lambda 的常量表达式中出现 // auto monad = [](auto v){ return [=]{ return v; }; }; auto bind = [](auto m){ return [=](auto fvm){ return fvm(m()); }; }; // 允许捕获在常量表达式求值期间创建的自动对象 static_assert(bind(monad(2))(monad)() == monad(2)());

    (C++17 起)

额外要求

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

即使表达式 E 未计算上述任何内容，若对 E 进行求值将涉及以下任意情形，则 E 是否为核心常量表达式是未指定的：

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

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

为确定表达式是否为核心常量表达式，对 union 的平凡拷贝/移动构造函数或拷贝/移动赋值运算符的调用，其求值过程被视为拷贝/移动该union的活动成员（如果存在）。

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

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

整型常量表达式

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

如果需要在期望整型常量表达式的地方使用类类型的表达式，该表达式将被 上下文隐式转换 为整型或无作用域枚举类型。

转换后的常量表达式

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

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

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

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

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

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

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

• noexcept 规范说明

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

下列表达式或转换是 可能被常量求值的 ：

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

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

变量在以下情况下 需要进行常量求值 ：如果它是 constexpr 变量，或者是非 volatile const 限定的整型类型或引用类型，且 标识符表达式 所指向的内容可能被常量求值。

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

常量子表达式

常量子表达式 是指作为表达式 e 的 子表达式 进行求值时，不会阻止 e 成为 核心常量表达式 的表达式，其中 e 不能是以下任意表达式：

• throw 表达式

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

注释

示例

缺陷报告

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

另请参阅