常量表达式

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

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

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

核心常量表达式

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

this 指针，除了在 constexpr 函数之中作为该表达式的一部分求值的情况
经过静态或线程存储期变量声明，并且不可用于常量表达式的控制流

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

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

调用已声明但未定义的 constexpr 函数
调用实例化无法满足constexpr 函数/构造函数要求的 constexpr 函数/构造函数模板
调用 constexpr 虚函数，除了所用的对象可用于常量表达式或它的生存期始于此表达式内的情况
会超出实现定义的极限的表达式

导致任何形式的核心语言未定义行为或错误行为 (C++26 起)的操作，不包括由标准属性引入的潜在未定义行为 (C++11 起)

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]; // 行为未定义，但未指定是否检测

(C++17 前) lambda 表达式

左值到右值隐式转换，除非应用于以下非 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 不可用于常量表达式
                  // 因为它的初始化器不是常量初始化器
}

指代生命期始于此表达式的求值之内的非 volatile 对象

对联合体的不活跃成员或它们的子对象实施的左值到右值隐式转换或修改操作（即使它与活跃成员共享公共起始序列也是如此）
(C++20 起) 应用到拥有不确定值的对象的左值到右值隐式转换
对活跃成员（如果存在）是 mutable 的联合体调用隐式定义的复制/移动构造函数或复制/移动赋值运算符，除非该联合体对象的生存期始于此表达式的求值之内
(C++20 前) 会更改联合体的活跃成员的赋值表达式
指代引用类型的变量或数据成员的标识表达式，除非该引用可用于常量表达式，或它的生存期始于此表达式的求值之内
从 void 指针转换到对象指针类型 T*，除非这个指针持有空指针值或者指向一个与类型 T 相似的对象 (C++26 起)
(C++20 前) dynamic_cast
reinterpret_cast
(C++20 前) 伪析构函数调用
(C++14 前) 自增或自减运算符

(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) 之内开始

(C++20 起) 对于生存期不在此表达式的求值内开始的对象的析构函数调用或伪析构函数调用
(C++20 前) 应用到多态类型泛左值的 typeid 表达式

new 表达式，除非满足以下任一条件： (C++20 起)

选中的分配函数是全局可替换分配函数，且它分配的存储会在此表达式的求值内解分配。

(C++20 起)

选中的分配函数是分配类型为 T 的不分配形式，并且布置实参满足以下所有条件：

它指向一个与 T 类型对象（如果 T 不是数组类型）或 T 类型对象的首个元素（如果 T 是数组类型）指针可以互相转换的对象。
它指向存储期在此表达式的求值内开始的存储。

(C++26 起)

delete 表达式，除非它解分配的是此表达式的求值内分配的存储区域 (C++20 起)
(C++20 起) 协程：await 表达式或 yield 表达式
(C++20 起) 结果未指定的三路比较运算符
结果未指定的相等或关系运算符
(C++14 前) 赋值或复合赋值运算符
throw 表达式
汇编声明
宏 va_arg 的调用
goto 语句
会抛出异常的 dynamic_cast 或 typeid 表达式

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 是否还是核心常量表达式：

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

对声明有 `[[noreturn]]` 属性的函数进行的调用，而该调用会返回调用方。	(C++11 起)
一条假设 `[[assume(expr)]]`;，其中如果 expr 在该假设出现处求值，那么结果不是 true，并且 E 也不会因此（即在对 expr 的虚设求值中会对前一列表中任何一项求值）而变得不是核心常量表达式。	(C++23 起)

注意：核心常量表达式本身并无任何直接的语义含义：表达式必须是常量表达式的子集之一（见后述），才可以在特定语境中使用。

常量表达式

常量表达式 是

指代下列之一的左值 (C++14 前)泛左值 (C++14 起)核心常量表达式：

拥有静态存储期且非临时的对象，或

拥有静态存储期的临时对象，但它的值满足下文对纯右值的约束，或

(C++14 起)

非立即 (C++20 起)函数

它的值满足下列约束的纯右值核心常量表达式：

如果它的值是类类型对象，那么它的每个引用类型的非静态数据成员均指代满足上述对左值 (C++14 前)泛左值 (C++14 起)约束的实体
如果它的值是标量类型对象，那么它不具有不确定值或错误值 (C++26 起)
如果它的值具有指针类型，那么它保有

拥有静态存储期的对象的地址
拥有静态存储期的对象的末尾后一位置的地址
非立即 (C++20 起)函数的地址
空指针值

如果它的值具有成员函数指针类型，那么它不代表立即函数

(C++20 起)

如果它的值具有类或数组类型，那么每个子对象均满足这些对值的约束

void test()
{
    static const int a = std::random_device{}();
    constexpr const int& ra = a; // OK：a 是泛左值常量表达式
    constexpr int ia = a; // 错误：a 不是纯右值常量表达式
 
    const int b = 42;
    constexpr const int& rb = b; // 错误：b 不是泛左值常量表达式
    constexpr int ib = b; // OK：b 是纯右值常量表达式
}

整数常量表达式

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

下列语境要求整数常量表达式：

数组边界
new 表达式中首个以外的维度

(C++14 前)

位域长度
底层类型未固定时的枚举初始化器
对齐

经转换的常量表达式

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

(C++17 起)

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

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

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

数组边界 new 表达式中，第一维以外的维度	(C++14 起)
参数包索引表达式和参数包索引说明符的索引	(C++26 起)

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

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

noexcept 说明

static_assert 声明	(C++23 前)
constexpr if 语句	(C++17 起) (C++23 前)
条件性 explicit 说明符	(C++20 起)

历史类别

下列常量表达式的类别从 C++14 起在标准中不再使用：

字面常量表达式 是非指针字面类型（经语境所要求的转换后）的纯右值核心常量表达式。数组或类类型的字面常量表达式要求每个子对象以常量表达式初始化。

引用常量表达式 是指代具有静态存储期的对象或指代函数的左值核心常量表达式。

地址常量表达式 是 std::nullptr_t 类型或指针类型（经语境所要求的转换后）的纯右值核心常量表达式，它指向具有静态存储期的对象，指向具有静态存储期的数组末尾后一位置，指向函数，或者是空指针。

常量子表达式

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

throw 表达式

yield 表达式

(C++20 起)

(C++17 起)

可用于常量表达式

上述列表中，在 P 点满足以下条件的变量可用于常量表达式：

该变量是

constexpr 变量，或
拥有下列类型的常量初始化的变量

引用类型，或
const 限定的整数或枚举类型

该变量的定义从 P 可达。

如果 P 不在与该变量定义相同的翻译单元中（即定义是被导入的），那么该变量未被初始化为指向或指代，或拥有（可能递归的）子对象或成员指向或指代可用于常量表达式的翻译单元局部实体。

(C++20 起)

以下对象或引用可用于常量表达式：

可用于常量表达式的变量

模板形参对象

(C++20 起)

字符串字面量对象
以上任一者的非 mutable 子对象或引用成员
具有无 volatile 限定但有 const 限定的类型的临时对象，并且它的生存期被延续到与某个可用于常量表达式的变量相同

const std::size_t sz = 10; // sz 可用于常量表达式

明显常量求值的表达式

下列表达式（包括到目标类型的转换）是明显常量求值 的：

数组边界
new 表达式中第一维以外的维度
位域长度
枚举项的初始化器
对齐
case 标号的常量表达式
非类型模板实参
noexcept 说明中的表达式
static_assert 声明中的表达式
constexpr 变量的初始化器

constexpr if 语句中的条件

(C++17 起)

条件性 explicit 说明符中的表达式
立即调用
概念定义、嵌套要求及 requires 子句中的约束表达式，当确定约束是否满足时

(C++20 起)

引用类型和 const 限定的整数或枚举类型的变量的初始化器，仅当初始化器是常量表达式时
静态及线程局域变量的初始化器，仅当初始化器的所有子表达式（含构造函数调用和隐式转换）都是常量表达式时（即该初始化器是常量初始化器）

能用 std::is_constant_evaluated 和 if consteval (C++23 起) 检测求值是否在明显常量求值语境中出现。

为测试最后两类条件，编译器可能首先对初始化器进行试探性的常量求值。不建议依赖此时的结果。

int y = 0;
const int a = std::is_constant_evaluated() ? y : 1;
// 试探性常量求值失败。放弃常量求值。
// 变量 a 被动态初始化为 1
 
const int b = std::is_constant_evaluated() ? 2 : y;
// 以 std::is_constant_evaluation() == true 进行的常量求值成功。
// 变量 b 被静态初始化为 2

(C++20 起)

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

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

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

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

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

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

注解

实现不能将库函数声明为 constexpr，除非标准指定该函数为 constexpr。

常量表达式中不容许具名返回值优化，而返回值优化是强制要求的。

功能特性测试宏	值	标准	功能特性
`__cpp_constexpr_in_decltype`	201711L	(C++11) (DR)	当被常量求值所需要时，生成函数或变量的定义
`__cpp_constexpr_dynamic_alloc`	201907L	(C++20)	constexpr 函数中的动态存储期操作
`__cpp_constexpr`	202306L	(C++26)	从 void* 进行 constexpr 转型：走向 constexpr 类型擦除
`__cpp_constexpr`	202406L	(C++26)	constexpr 的布置 new 和 new[]

缺陷报告

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

缺陷报告	应用于	出版时的行为	正确行为
CWG 1293	C++11	未指明字符串字面量是否可用于常量表达式	可用于常量表达式
CWG 1311	C++11	可以在常量表达式中使用 volatile 泛左值	禁止使用
CWG 1312	C++11	已禁止在常量表达式中使用 reinterpret_cast，但是转换到 void* 再转换到其他类型可以达到一样的效果	禁止从 cv void* 类型转换到对象指针类型
CWG 1313	C++11	容许未定义行为；且禁止所有指针减法	禁止未定义行为；允许同数组内的指针减法
CWG 1405	C++11	可用于常量表达式的对象的可变子对象也可用于常量表达式	不可用于常量表达式
CWG 1454	C++11	不能通过 constexpr 函数以引用传递常量	已允许
CWG 1455	C++11	经转换的常量表达式只能是纯右值	可以是左值
CWG 1456	C++11	地址常量表达式不能表示数组末尾后一位置	可以表示
CWG 1535	C++11	操作数是/具有多态类类型的 typeid 表达式即使不会涉及运行时检查也不是核心常量表达式	操作数限制仅限于多态类类型的泛左值
CWG 1581	C++11	未要求定义或实例化常量求值所需要的函数	已要求
CWG 1694	C++11	绑定临时量的值到静态存储期引用是常量表达式	它不是常量表达式
CWG 1952	C++11	要求诊断标准库未定义行为	未指定是否诊断库未定义行为
CWG 2126	C++11	具有有 const 限定的字面类型且生存期因常量初始化延续的临时量不能用于常量表达式	可以用于常量表达式
CWG 2167	C++11	求值中局部的非成员引用会令求值为非 constexpr	允许非成员引用
CWG 2299	C++14	未指明 `<cstdarg>` 中的宏能否用于常量求值	禁止 `va_arg`，未指定 `va_start`
CWG 2400	C++11	包含对 constexpr 虚函数的函数调用的表达式在调用所用的对象不可用于常量表达式且它的生命期在此表达式之外开始时也可以是常量表达式	它不是常量表达式
CWG 2418	C++11	未指明不是变量的对象和引用中有哪些可用于常量表达式	已指明
CWG 2490	C++20	常量求值中的（伪）析构函数调用缺少限制	添加了限制
CWG 2558	C++11	不确定值可以是常量表达式	不是常量表达式
CWG 2763	C++11	在常量求值中不需要检测是否违背了 `[[noreturn]]`	需要检测
CWG 2851	C++11	经转换的常量表达式不允许浮点转换	允许非窄化浮点转换

参阅

`constexpr` 说明符(C++11)	指定变量或函数的值能在编译时计算
is_literal_type (C++11)(C++17 中弃用)(C++20 中移除)	检查类型是否为字面类型 (类模板)

编译器支持
自立实现与有宿主实现
语言
标准库
标准库标头
具名要求
功能特性测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用工具库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
技术规范
符号索引
外部库

常量表达式

核心常量表达式

常量表达式

整数常量表达式

经转换的常量表达式

历史类别

常量子表达式

可用于常量表达式

明显常量求值的表达式

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

注解

缺陷报告

参阅

导航