`constexpr` 说明符 (自 C++11 起)

constexpr - 指定变量或函数的值可以出现在常量表达式中

内容

1 解释
2 注意
3 关键字
4 示例
5 缺陷报告
6 另请参阅

[编辑] 解释

constexpr 说明符声明在编译时可以评估函数或变量的值。然后，这些变量和函数可以在仅允许编译时常量表达式的地方使用（前提是给出了适当的函数参数）。

在对象声明或非静态成员函数(C++14 之前) 中使用的 constexpr 说明符意味着 const。在函数或静态数据成员(自 C++17 起) 声明中使用的 constexpr 说明符意味着 inline。如果函数或函数模板的任何声明都包含 constexpr 说明符，则每个声明都必须包含该说明符。

[编辑] constexpr 变量

constexpr 变量必须满足以下要求

其类型必须是 LiteralType
它必须立即初始化
其初始化的完整表达式，包括所有隐式转换、构造函数调用等，必须是常量表达式

它必须具有常量析构，即：

它不是类类型，也不是（可能是多维的）类类型的数组，或者
如果它是类类型或（可能的多维）类类型的数组，该类类型具有一个 constexpr 析构函数，并且对于一个假设的表达式 e，其唯一作用是销毁对象，e 将是一个核心常量表达式，如果对象的生存期及其非可变子对象（但不是其可变子对象）被认为是在 e 内开始的。

如果一个 constexpr 变量不是翻译单元局部的，它不应该被初始化为引用一个在常量表达式中可用的翻译单元局部实体，也不应该有一个子对象引用这样一个实体。这种初始化在模块接口单元（在其私有模块片段之外，如果有的话）或模块分区中是不允许的，并且在任何其他上下文中都是不推荐的。

(自 C++20 起)

[编辑] constexpr 函数

一个 constexpr 函数 必须满足以下要求

它不能是虚函数它不能是函数 try 块	(直到 C++20)
它不能是协程	(自 C++20 起)

对于构造函数和析构函数(自 C++20 起)，该类必须没有虚基类

它的返回值（如果有）和它的每个参数必须是 LiteralType
至少存在一组参数值，使得函数的调用可以是核心常量表达式的一个已计算的子表达式（对于构造函数，在常量初始化中使用就足够了）。对于违反此要点，不需要诊断。

(直到 C++23)

函数体必须是删除的或默认的，或者仅包含以下内容：

空语句（纯分号）
static_assert 声明
typedef 声明和别名声明，它们不定义类或枚举
使用声明
使用指令
如果函数不是构造函数，则只有一个 return 语句

(直到 C++14)

函数体必须不包含：:

一个 goto 语句
带有标签的语句，除了 case 和 default

一个 try 块
一个 asm 声明
一个变量的定义，该变量没有执行初始化

(直到 C++20)

一个非文字类型的变量的定义
一个静态或线程存储期的变量的定义

(一个函数体是 = default; 或 = delete; 不包含以上任何内容。）

(自 C++14 起)
(直到 C++23)

constexpr 构造函数

一个 constexpr 构造函数，其函数体不是 = delete; 必须满足以下额外要求

对于类或结构体的构造函数，每个基类子对象和每个非变体非静态数据成员必须被初始化。如果该类是联合类，对于它的每个非空匿名联合成员，必须恰好初始化一个变体成员
对于非空联合体的构造函数，必须恰好初始化一个非静态数据成员

(直到 C++20)

每个用于初始化非静态数据成员和基类的构造函数必须是一个 constexpr 构造函数。

constexpr 析构函数

析构函数不能是 constexpr，但平凡析构函数可以隐式地调用在常量表达式中。

(直到 C++20)

一个 constexpr 析构函数，其函数体不是 = delete; 必须满足以下额外要求

每个用于销毁非静态数据成员和基类的析构函数必须是一个 constexpr 析构函数。

(自 C++20 起)

(直到 C++23)

对于 constexpr 函数模板和类模板的 constexpr 成员函数，至少一个特化必须满足上述要求。其他特化仍然被认为是 constexpr，即使对这样一个函数的调用不能出现在常量表达式中。

如果没有模板特化在被视为非模板函数时会满足 constexpr 函数的要求，则该模板格式错误，不需要诊断。

(直到 C++23)

一个 constexpr 函数如果未标记 consteval，以非常量方式使用立即函数，并且是

一个 lambda 的调用运算符，或者
一个默认的特殊成员函数，或者
一个标记为 constexpr 的模板实体的特化。

(自 C++20 起)

[编辑] 注释

因为 noexcept 运算符始终为常量表达式返回 true，所以它可以用于检查 constexpr 函数的特定调用是否采用常量表达式分支

constexpr int f(); 
constexpr bool b1 = noexcept(f()); // false, undefined constexpr function
constexpr int f() { return 0; }
constexpr bool b2 = noexcept(f()); // true, f() is a constant expression

(直到 C++17)

可以编写一个 constexpr 函数，其调用永远无法满足核心常量表达式的要求

void f(int& i) // not a constexpr function
{
    i = 0;
}
 
constexpr void g(int& i) // well-formed since C++23
{
    f(i); // unconditionally calls f, cannot be a constant expression
}

(自 C++23 起)

对于不是文字类型的类，允许使用 constexpr 构造函数。例如，std::shared_ptr 的默认构造函数是 constexpr，允许常量初始化。

引用变量可以声明为 constexpr（它们的初始化器必须是引用常量表达式）

static constexpr int const& x = 42; // constexpr reference to a const int object
                                    // (the object has static storage duration
                                    //  due to life extension by a static reference)

即使 try 块和内联汇编在 constexpr 函数中是允许的，在常量表达式中仍然不允许抛出异常或执行汇编。

如果一个变量具有常量销毁，则不需要生成机器码来调用它的析构函数，即使它的析构函数不是平凡的。

一个非 lambda、非特殊成员和非模板化的 constexpr 函数不能隐式地成为一个立即函数。用户需要显式地将其标记为 consteval 以使这样一个预期的函数定义格式正确。

(自 C++20 起)

功能测试宏	值	Std	功能
`__cpp_constexpr`	200704L	(C++11)	constexpr
	201304L	(C++14)	放宽的 constexpr，非 const constexpr 方法
	201603L	(C++17)	Constexpr lambda
	201907L	(C++20)	平凡的默认初始化和 asm-声明在 constexpr 函数中
	202002L	(C++20)	在常量计算中改变联合体的活动成员
	202110L	(C++23)	非文字变量、标签和 `goto` 语句在 constexpr 函数中
	202207L	(C++23)	放宽一些 constexpr 限制
	202211L	(C++23)	允许 static constexpr 变量在 constexpr 函数中
	202306L	(C++26)	从 void* 的 constexpr 转换：面向 constexpr 类型擦除
`__cpp_constexpr_in_decltype`	201711L	(C++11) (DR)	当需要用于常量计算时，生成函数和变量定义
`__cpp_constexpr_dynamic_alloc`	201907L	(C++20)	在 constexpr 函数中用于动态存储期的运算

[编辑] 关键字

constexpr

[编辑] 示例

定义 C++11/14 constexpr 函数，计算阶乘；定义一个文字类型，扩展字符串文字

运行这段代码

#include <iostream>
#include <stdexcept>
 
// C++11 constexpr functions use recursion rather than iteration
constexpr int factorial(int n)
{
    return n <= 1 ? 1 : (n * factorial(n - 1));
}
 
// C++14 constexpr functions may use local variables and loops
#if __cplusplus >= 201402L
constexpr int factorial_cxx14(int n)
{
    int res = 1;
    while (n > 1)
        res *= n--;
    return res;
}
#endif // C++14
 
// A literal class
class conststr
{
    const char* p;
    std::size_t sz;
public:
    template<std::size_t N>
    constexpr conststr(const char(&a)[N]): p(a), sz(N - 1) {}
 
    // constexpr functions signal errors by throwing exceptions
    // in C++11, they must do so from the conditional operator ?:
    constexpr char operator[](std::size_t n) const
    {
        return n < sz ? p[n] : throw std::out_of_range("");
    }
 
    constexpr std::size_t size() const { return sz; }
};
 
// C++11 constexpr functions had to put everything in a single return statement
// (C++14 does not have that requirement)
constexpr std::size_t countlower(conststr s, std::size_t n = 0,
                                             std::size_t c = 0)
{
    return n == s.size() ? c :
        'a' <= s[n] && s[n] <= 'z' ? countlower(s, n + 1, c + 1)
                                   : countlower(s, n + 1, c);
}
 
// An output function that requires a compile-time constant, for testing
template<int n>
struct constN
{
    constN() { std::cout << n << '\n'; }
};
 
int main()
{
    std::cout << "4! = ";
    constN<factorial(4)> out1; // computed at compile time
 
    volatile int k = 8; // disallow optimization using volatile
    std::cout << k << "! = " << factorial(k) << '\n'; // computed at run time
 
    std::cout << "The number of lowercase letters in \"Hello, world!\" is ";
    constN<countlower("Hello, world!")> out2; // implicitly converted to conststr
 
    constexpr int a[12] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
    constexpr int length_a = sizeof a / sizeof(int); // std::size(a) in C++17,
                                                      // std::ssize(a) in C++20
    std::cout << "Array of length " << length_a << " has elements: ";
    for (int i = 0; i < length_a; ++i)
        std::cout << a[i] << ' ';
    std::cout << '\n';
}

输出

4! = 24
8! = 40320
The number of lowercase letters in "Hello, world!" is 9
Array of length 12 has elements: 0 1 2 3 4 5 6 7 8 0 0 0

[编辑] 缺陷报告

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

DR	应用于	已发布的行为	正确行为
CWG 1712	C++14	要求 constexpr 变量模板的所有声明都包含 constexpr 说明符 (它现在是冗余的，因为不可能有多个带有 constexpr 说明符的变量模板声明)	不再需要
CWG 1911	C++11	不允许对非文字类型使用 constexpr 构造函数	允许在常量初始化中使用
CWG 2004	C++11	带有可变成员的联合体的复制/移动在常量表达式中是允许的	可变变体会取消资格隐式复制/移动
CWG 2163	C++14	在 constexpr 函数中允许使用标签即使 gotos 被禁止	标签也被禁止
CWG 2268	C++11	带有可变成员的联合体的复制/移动被由CWG 问题 2004 的决议禁止。	如果对象是在常量表达式中创建的，则允许。

[编辑] 另请参阅

常量表达式	定义一个可以在编译时求值的表达式。
`consteval` 说明符(C++20)	指定函数是立即函数，即对函数的每次调用都必须在常量求值中进行。 [编辑]
`constinit` 说明符(C++20)	断言变量具有静态初始化，即零初始化和常量初始化。 [编辑]
C 文档针对 constexpr

编译器支持
独立和托管
语言
标准库
标准库头文件
命名需求
功能测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用实用程序库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
执行支持库 (C++26)
技术规范
符号索引
外部库

cppreference.com

命名空间

变体

视图

操作

`constexpr` 说明符 (自 C++11 起)

内容

[编辑] 解释

[编辑] constexpr 变量

[编辑] constexpr 函数

constexpr 构造函数

constexpr 析构函数

[编辑] 注释

[编辑] 关键字

[编辑] 示例

[编辑] 缺陷报告

[编辑] 另请参阅

导航

工具箱

cppreference.com

命名空间

变体

视图

操作

constexpr 说明符 (自 C++11 起)

内容

[编辑] 解释

[编辑] constexpr 变量

[编辑] constexpr 函数

constexpr 构造函数

constexpr 析构函数

[编辑] 注释

[编辑] 关键字

[编辑] 示例

[编辑] 缺陷报告

[编辑] 另请参阅

导航

工具箱

`constexpr` 说明符 (自 C++11 起)