常量表达式

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

这种表达式能用作常量模板实参、数组大小，并用于其他要求常量表达式的语境，例如

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

[编辑] 定义

当确定表达式是否为常量表达式时始终会假设不进行复制消除。

C++98 的常量表达式定义全部在上面的折叠盒中。以下描述适用于 C++11 以及后续 C++ 版本。

[编辑] 字面类型

字面类型 是下列之一：

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

• 它拥有平凡析构函数(C++20 前) constexpr 析构函数(C++20 起)，
• 它的所有非静态非可变数据成员和基类都具有非 volatile 字面类型。
• 它是以下类型之一：

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

• 它没有变体成员。
• 它至少有一个具有无 volatile 限定的字面类型的变体成员。

• 每个匿名联合体成员都满足以下任一条件的非联合体聚合类型：

• 没有变体成员。
• 至少有一个具有无 volatile 限定的字面类型的变体成员。

• 拥有至少一个 constexpr 构造函数（模板）且非复制或移动构造函数的类型

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

[编辑] 核心常量表达式

核心常量表达式 是求值过程中不会对下列任一语言构造求值的表达式：

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

   constexpr int n = std::numeric_limits<int>::max(); // OK：max() 是 constexpr
   constexpr int m = std::time(NULL); // 错误：std::time() 非 constexpr

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

   constexpr double d1 = 2.0 / 1.0; // OK
   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]; // OK
   constexpr std::bitset<2> a; 
   constexpr bool b = a[2]; // 行为未定义，但未指定是否检测

7. (C++17 前) lambda 表达式
8. 左值到右值隐式转换，除非应用于：
   1. （可有 cv 限定的）std::nullptr_t 类型的泛左值
   2. 指代可用于常量表达式的对象的非 volatile 字面类型的泛左值

      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. 指代生命期始于此表达式的求值之内的非 volatile 对象的非 volatile 字面类型的泛左值
9. 对联合体的不活跃成员或它们的子对象实施的左值到右值隐式转换或修改操作（即使它与活跃成员共享公共起始序列也是如此）
10. (C++20 起) 应用到拥有不确定值的对象的左值到右值隐式转换
11. 对活跃成员（如果存在）是 mutable 的联合体调用隐式定义的复制/移动构造函数或复制/移动赋值运算符，除非该联合体对象的生存期始于此表达式的求值之内
12. (C++20 前) 会更改联合体的活跃成员的赋值表达式
13. 从 void 指针转换到对象指针类型 T*，除非这个指针持有空指针值或者指向一个与类型 T 相似的对象(C++26 起)
14. 操作数所指代对象的动态类型为 constexpr 未知的(C++20 起) dynamic_cast
15. reinterpret_cast
16. (C++20 前) 伪析构函数调用
17. (C++14 前) 自增或自减运算符
18. (C++14 起) 修改对象，除非该对象拥有非 volatile 字面类型，且它的生存期始于此表达式的求值之内

    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); // OK：不要求 x 以核心常量表达式初始化
        return x;
    }
     
    constexpr int y = h(1); // OK：以值 2 初始化 y
                            // h(1) 是核心常量表达式
                            // 因为 k 的生存期始在表达式 h(1) 之内开始

19. (C++20 起) 对于生存期不在此表达式的求值内开始的对象的析构函数调用或伪析构函数调用
20. 应用到多态类型泛左值，且该泛左值所指代对象的动态类型为 constexpr 未知(C++20 起)的 typeid 表达式
21. new 表达式，除非满足以下任一条件：(C++20 起)

    选中的分配函数是全局可替换分配函数，且它分配的存储会在此表达式的求值内解分配。	(C++20 起)
    选中的分配函数是分配类型为 T 的不分配形式，并且布置实参满足以下所有条件： 它指向： 某个类型与 T 相似的对象，如果 T 不是数组类型，或者 某个类型与 T 相似的对象的首个元素，如果 T 是数组类型。 它指向存储期在此表达式的求值内开始的存储。	(C++26 起)

22. delete 表达式，除非它解分配的是此表达式的求值内分配的存储区域(C++20 起)
23. (C++20 起) 协程：await 表达式或 yield 表达式
24. (C++20 起) 结果未指定的三路比较运算符
25. 结果未指定的相等或关系运算符
26. (C++14 前) 赋值或复合赋值运算符
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)); // OK
    static_assert(!is_ok(-1)); // C++26 起 OK
    static_assert(always_throw()); // 错误：未捕获异常

29. 汇编声明
30. 宏 va_arg 的调用
31. goto 语句
32. 会抛出异常的 dynamic_cast 或 typeid 表达式或 new 表达式(C++26 起)，且其中异常类型的定义不可达(C++26 起)
33. lambda 表达式中，提�� this 或提及于该 lambda 之外定义的变量，如果它是一次 ODR 使用

    void g()
    {
        const int n = 0;
     
        constexpr int j = *&n; // OK：lambda 表达式之外
     
        [=]
        {
            constexpr int i = n;  // OK：'n' 未被 ODR 使用且未在此处被俘获。
            constexpr int j = *&n;// 非良构：'&n' ODR 使用了 'n'。
        };
    }

    注意，如果 ODR 使用在对闭包的函数调用中发生，那么它不涉指 this 或外围变量，因为它所访问的是该闭包的数据成员 // OK：'v' 与 'm' 被 ODR 使用，但没有在嵌套于 lambda 内的常量表达式中出现 auto monad = [](auto v){ return [=]{ return v; }; }; auto bind = [](auto m){ return [=](auto fvm){ return fvm(m()); }; };   // 在常量表达式求值中，创建对自动对象的俘获是 OK 的。 static_assert(bind(monad(2))(monad)() == monad(2)());

    (C++17 起)

[编辑] 额外要求

即使表达式 E 不会求值以上任何一项，但是如果求值它会导致运行时未定义行为，那么由实现定义 E 是否还是核心常量表达式。

即使表达式 E 不会求值以上任何一项，但是如果求值它会导致求值以下任何一项，那么未指定 E 是否还是核心常量表达式：

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

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

为确定表达式是否为核心常量表达式，对联合体的平凡的复制/移动构造函数和复制/移动赋值运算符的调用会被视为复制/移动该联合体的活跃成员，如果存在。

在表达式作为核心常量表达式的求值过程中，所有标识表达式和 *this 的使用，如果它指代的是在该表达式求值之外已经开始生存期的对象或引用，那么都被当做指代这个对象或引用的特定实例，且它和它的所有子对象（包括所有联合体成员）的生存期包含整个常量求值。

• 对于不可用于常量表达式的这种对象，对象的动态类型即是 constexpr 未知的。
• 对于不可用于常量表达式的这种引用，将引用当做绑定到某个未指明的被引用类型的对象，它和它的所有子对象的生存期包含整个常量求值，且它的动态类型是 constexpr 未知的。

[编辑] 整数常量表达式

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

如果期待整数常量表达式的地方使用类类型表达式，那么该表达式将被按语境隐式转换成整数类型或无作用域枚举类型。

[编辑] 经转换的常量表达式

T 类型的经转换的常量表达式 是隐式转换到 T 类型的表达式，其中被转换后表达式是常量表达式，且隐式转换序列只含有：

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

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

下列语境要求经转换的常量表达式：

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

按语境转换的 bool 类型的常量表达式 是按语境转换到 bool 的表达式，其中经转换的表达式是常量表达式，且转换序列只含上述转换。

下列语境要求按语境转换的 bool 类型的常量表达式：

• noexcept 说明

[编辑] 常量求值所需要的函数与变量

下列表达式或转换会潜在常量求值：

• 明显常量求值的表达式
• 潜在求值的表达式
• 花括号包围的初始化器列表的直接子表达式（可能需要常量求值以确定转换是否为窄化）
• 在模板化实体内出现的取址表达式（可能需要常量求值以确定这种表达式是否为值待决）
• 上述之一的子表达式，除了嵌套的不求值操作数的子表达式

如果函数是 constexpr 函数且被潜在常量求值的表达式所指名，那么它被常量求值所需要。

如果变量是 constexpr 变量或非 volatile 的 const 限定的整数类型或引用类型的变量，且指代它的标识表达式被潜在常量求值，那么它被常量求值所需要。

如果预置函数或函数模板特化或变量模板特化(C++14 起)被常量求值所需要，则出会触发该函数或变量(C++14 起)的（预置函数）定义或（模板特化）实例化。

[编辑] 常量子表达式

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

• throw 表达式

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

[编辑] 注解

[编辑] 示例

[编辑] 缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

[编辑] 参阅