constexpr specifier (since C++11)

• constexpr - 指定变量 、 结构化绑定 (C++26 起) 或函数的值可以出现在 常量表达式 中

说明

constexpr 说明符声明可以在编译时对实体的值进行计算。随后这类实体便可在仅允许使用编译期 常量表达式 的场合使用（前提是提供了适当的函数参数）。

在对象声明 或非静态成员函数 (until C++14) 中使用的 constexpr 说明符隐含 const 语义。

在函数 或 静态 数据成员 (C++17起) 的首次声明中使用的 constexpr 说明符隐含 inline 。若函数或函数模板的任意声明含有 constexpr 说明符，则所有声明都必须包含该说明符。

constexpr 变量

若满足以下所有条件，变量 或变量模板 (C++14 起) 可被声明为 constexpr ：

• 该声明是一个 定义 。
• 它属于 字面类型 。
• 它（通过该声明）被初始化。

constexpr 函数

函数或函数模板可被声明为 constexpr 。

一个函数是 constexpr-suitable 的，当且仅当满足以下所有条件：

• 若它是构造函数 或析构函数 (C++20 起) ，则其类没有任何 虚基类 。

除了实例化的 constexpr 函数外，非模板化的 constexpr 函数必须满足 constexpr 适用条件。

在给定上下文中调用 constexpr 函数产生的结果，与在相同上下文中调用等效非 constexpr 函数的结果在所有方面均相同，但存在以下例外情况：

• constexpr 函数的调用可以出现在 常量表达式 中。
• 在常量表达式中不会执行 拷贝消除 。

constexpr 构造函数

除了对 constexpr 函数的要求之外，构造函数还需要满足以下所有条件才能适用于 constexpr：

• 该类没有任何 virtual base class 。

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

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
}

对于非字面类型的类，允许使用常量表达式构造函数。例如， std::shared_ptr 的默认构造函数是 constexpr 的，这使得 常量初始化 成为可能。

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

static constexpr int const& x = 42; // 指向常量整型对象的 constexpr 引用
                                    // （该对象具有静态存储期
                                    //  因静态引用引发的生命周期延长）

关键词

constexpr

示例

#include <iostream>
#include <stdexcept>
// C++11 constexpr 函数使用递归而非迭代
constexpr int factorial(int n)
{
    return n <= 1 ? 1 : (n * factorial(n - 1));
}
// C++14 constexpr 函数可使用局部变量和循环
#if __cplusplus >= 201402L
constexpr int factorial_cxx14(int n)
{
    int res = 1;
    while (n > 1)
        res *= n--;
    return res;
}
#endif // C++14
// 字面量类
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 函数通过抛出异常来报告错误
    // 在 C++11 中，必须通过条件运算符 ?: 实现
    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 函数必须将所有内容放在单个 return 语句中
//（C++14 无此要求）
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);
}
// 用于测试的需编译时常量的输出函数
template<int n>
struct constN
{
    constN() { std::cout << n << '\n'; }
};
int main()
{
    std::cout << "4! = ";
    constN<factorial(4)> out1; // 编译时计算
    volatile int k = 8; // 使用 volatile 禁止优化
    std::cout << k << "! = " << factorial(k) << '\n'; // 运行时计算
    std::cout << "The number of lowercase letters in \"Hello, world!\" is ";
    constN<countlower("Hello, world!")> out2; // 隐式转换为 conststr
    constexpr int a[12] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
    constexpr int length_a = sizeof a / sizeof(int); // C++17 中的 std::size(a)，
                                                      // C++20 中的 std::ssize(a)
    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++标准。

1. ↑ 这是冗余的，因为使用 constexpr 说明符的变量模板不能有多个声明。

参见