常量表达式

表达式

概述
值类别（左值 lvalue、右值 rvalue、亡值 xvalue）
求值顺序（序列点）
常量表达式
不求值表达式
初等表达式
lambda 表达式(C++11)
字面量
整数字面量
浮点字面量
布尔字面量
字符字面量，包含转义序列
字符串字面量
空指针字面量(C++11)
用户定义字面量(C++11)
运算符
赋值运算符: `a=b`, `a+=b`, `a-=b`, `a*=b`, `a/=b`, `a%=b`, `a&=b`, `a\|=b`, `a^=b`, `a<<=b`, `a>>=b`
自增与自减: `++a`, `--a`, `a++`, `a--`
算术运算符: `+a`, `-a`, `a+b`, `a-b`, `a*b`, `a/b`, `a%b`, `~a`, `a&b`, `a\|b`, `a^b`, `a<<b`, `a>>b`
逻辑运算符: `a\|\|b`, `a&&b`, `!a`
比较运算符: `a==b`, `a!=b`, `a<b`, `a>b`, `a<=b`, `a>=b`, `a<=>b`(C++20)
成员访问运算符: `a[b]`, `a`, `&a`, `a->b`, `a.b`, `a->b`, `a.*b`
其他运算符: `a(...)`, `a,b`, `a?b:c`
默认比较(C++20)
运算符的代用表示
优先级和结合性
折叠表达式(C++17)
new 表达式
delete 表达式
throw 表达式
alignof
sizeof
sizeof...(C++11)
typeid
noexcept(C++11)
运算符重载
类型转换
隐式转换
const_cast
static_cast
reinterpret_cast
dynamic_cast
显式转换 `(T)a`, `T(a)`
用户定义转换

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

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

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

核心常量表达式

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

this 指针，但作为该表达式的一部分求值的 constexpr 函数或 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 函数/构造函数的要求。
(C++20 起) 对 constexpr 虚函数的函数调用，调用所用的对象不可用于常量表达式（见后述）且其生命期始于此表达式之外。
会超出实现定义限制的表达式

求值导致任何形式的核心语言未定义行为（包含有符号整数溢出、除以零、数组边界外的指针算术等）的表达式。是否检测标准库的未定义行为是未指明的。

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

(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 对象

对 union 的不活跃成员或其子对象实施的左值到右值隐式转换或修改操作（即使它与活跃成员共享公共起始序列也是如此）
对活跃成员（若存在）为 mutable 的 union 调用隐式定义的复制/移动构造函数或复制/移动赋值运算符，除非该 union 对象的生命期始于此表达式的求值之内
(C++17 起) (C++20 前)会更改 union 的活跃成员的赋值表达式，或对重载的赋值运算符的调用
指代引用类型的变量或数据成员的标识表达式，除非该引用可用于常量表达式，或其生命始于此表达式的求值之内
从 cv void* 转换到任何对象指针类型
(C++20 前)dynamic_cast
reinterpret_cast
伪析构函数调用
(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 前)应用到多态类型泛左值的 typeid 表达式
new 表达式或 delete 表达式
(C++20 起)结果未指定三路比较
结果未指明的相等或关系运算符
(C++14 前)赋值或复合赋值运算符
throw 表达式
(C++20 起)会抛出异常的 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 起)

注意：核心常量表达式本身并无任何直接的语义含义：表达式必须为下列子集之一，才可以在特定语境中使用：

可用于常量表达式

上述列表中，变量可用于常量表达式，若它是

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

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

对象或引用可用于常量表达式，若它是

可用于常量表达式的变量，或
(C++20 起) 模板形参对象，或
字符串字面量对象，或
以上任一者的非 mutable 子对象或引用成员，或
非 volatile 的 const 限定整数类或枚举类型的，以常量表达式初始化的完整临时对象。

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

整型常量表达式

整型常量表达式是隐式转换成纯右值的整型或无作用域枚举类型的表达式，其中被转换的表达式是核心常量表达式。若将类类型表达式用在期待整型常量表达式之处，则表达式将被按语境隐式转换成整型或无作用域枚举类型。

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

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

(C++14 前)

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

空指针常量

(C++14 前)

对齐。

经转换的常量表达式

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

constexpr 用户定义转换（故类能用于期待整数类型之处）
左值到右值转换
整型提升
非窄化整型转换

数组到指针转换
函数到指针转换
函数指针转换（指向 noexcept 函数的指针到指向函数的指针）
限定性转换
源自 std::nullptr_t 的空指针转换
源自 std::nullptr_t 的空成员指针转换

(C++17 起)

而若发生任何引用绑定，则它是直接绑定（非构造临时对象者）

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

case 表达式
底层类型已固定时的枚举项初始化器

数组边界
new 表达式中，第一维以外的维度

(C++14 起)

整型与枚举 (C++17 前)非类型模板实参。

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

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

constexpr if 语句

(C++17 起)

条件性 explicit 说明符

(C++20 起)