Day5-constexpr 与编译期计算

constexpr 与编译期计算

C++进阶计划 · Day 5 | 预计学习时长：2小时

引言

Day 4 我们深入了 Lambda 表达式，掌握了 C++ 中函数式编程的利器。Day 3 的智能指针解决了运行时资源管理的难题，Day 2 的移动语义让值语义拥有了"零成本抽象"的能力。

但你有没有想过：这些问题能不能在编译期就解决？运行时的一分一秒都是代价，而编译期计算——只要代码能通过，运算结果就"免费"地嵌入到了二进制里。

constexpr 就是 C++ 给你的编译期计算能力。从 C++11 的"只能计算整数常量"，到 C++14 的"基本能写普通函数"，再到 C++17/20/23 的持续进化，constexpr 已经从玩具变成了实战利器。结合 Qt 开发场景，编译期计算能让你定义一些"永不改变"的常量、处理元组类型、生成编译期查找表——这些都是 7 年 Qt 老兵离不开的技巧。

今天的目标：从"知道 constexpr 关键字"进化到"在项目中自如运用编译期计算"。

核心概念

1. constexpr 的演进：从常量到计算

C++11：常量表达式

C++11 的 constexpr 只能用于非常有限的场景：

// C++11：只能声明常量，不能写复杂逻辑
constexpr int ARRAY_SIZE = 100;  // OK
constexpr int fib(int n) { return n <= 1 ? n : fib(n-1) + fib(n-2); }  // OK：递归+三元
constexpr int sum = fib(10);  // OK：编译期求值

限制：所有分支必须是常量表达式，不能有局部变量，不能有循环。

C++14：解放双手

C++14 大幅放宽了 constexpr 函数的限制：

// C++14：可以有局部变量、循环、多条语句
constexpr int fib(int n) {
    if (n <= 1) return n;
    int a = 0, b = 1;
    for (int i = 1; i < n; ++i) {
        int temp = a + b;
        a = b;
        b = temp;
    }
    return b;
}

C++17：支持 if 语句（ constexpr if 另有专文）

C++17 允许 constexpr 函数中使用 if 语句：

constexpr int abs(int x) {
    if (x < 0) return -x;
    return x;
}

C++20：允许 concept、requires、consteval 嵌套

C++20 的 constexpr 函数几乎可以写任意合法代码：

• 可以使用 dynamic_cast（编译期失败会导致编译错误）
• 可以使用 try-catch（但 catch 必须是不抛出异常的代码路径）
• 可以调用 std::bit_cast

C++23：更多标准库支持

C++23 的 constexpr 支持：

• std::vector 的某些操作（push_back、pop_back、clear、resize）
• std::unique_ptr、std::shared_ptr 的操作
• std::format 的部分功能

2. constexpr 变量：真正的常量

// 普通 const：不一定是编译期常量
const int getSize() { return 42; }
const int size = getSize();  // 运行时初始化

// constexpr：一定是编译期常量
constexpr int arr[getSize()];  // ❌ 编译错误：getSize() 不是 constexpr
constexpr int arr2[100];      // ✅ 编译期已知

核心区别：

• const：语义上"不可变"，但可能是运行时计算
• constexpr：语义上"编译期可计算"，值一定在编译时确定

// Qt 场景：使用 constexpr 定义信号槽连接数上限
class Constants {
    static constexpr int MAX_CONNECTIONS = 16;
    static constexpr int BUFFER_SIZE = 4096;
    static constexpr auto APP_VERSION = "2.1.0";  // C++17 字符串字面量
};

3. consteval（C++20）：强制编译期求值

consteval 是 C++20 引入的关键字，强制函数必须在编译期求值：

consteval int sqr(int x) { return x * x; }

constexpr int a = sqr(5);   // ✅ 编译期计算，a = 25
int b = 5;
constexpr int c = sqr(b);   // ❌ 编译错误：b 不是常量表达式
int d = sqr(b);             // ❌ 编译错误！consteval 函数不能在运行时调用

constexpr vs consteval：

实战场景：生成编译期类型标签

// 编译期生成类型标识
// ❌ 此代码无法编译：typeid 不是 constexpr，不能在 consteval 中使用
// consteval size_t type_id_of(auto&&) {
//     return reinterpret_cast<size_t>(typeid(decltype(auto)).name());
// }

// ✅ 正确做法：使用编译期类型特征
template<typename T>
consteval std::string_view type_name() {
    // C++23 才支持 constexpr std::string_view 与 typeid 结合
    // 更实际的方案：使用预定义宏或 __PRETTY_FUNCTION__ 解析
    return __PRETTY_FUNCTION__;  // 编译器扩展，在 consteval 上下文中可用
}

// 编译期字符串哈希（用于反射替代）
consteval uint32_t hash_string(const char* str, uint32_t h = 2166136261) {
    return *str ? hash_string(str + 1, (h ^ *str) * 16777619ULL) : h;
}

constexpr auto HASH_BUTTON = hash_string("Button");
constexpr auto HASH_LABEL = hash_string("Label");

void handle_event(uint32_t hash) {
    if constexpr (hash == HASH_BUTTON) {
        // ...
    }
}

4. constinit（C++20）：防止静态初始化陷阱

constinit 用于声明一个变量必须使用常量初始化，用于防止静态初始化顺序灾难：

// ❌ 危险：静态初始化顺序未定义（Static Init Order Fiasco）
inline int get_id() { static int counter = 0; return counter++; }
static int s_id = get_id();  // 可能在其他静态变量初始化前运行

// ✅ 安全：constinit 保证编译期常量初始化
constinit int s_safe_id = 42;  // OK
constinit int s_bad_id = get_id();  // ❌ 编译错误：get_id() 不是 constexpr

// 正确用法：constinit 确保变量以常量表达式初始化
constexpr int get_constexpr_id() { return 0; }
constinit int s_good_id = get_constexpr_id();  // OK

更实用的场景：线程安全的日志单例

class Logger {
public:
    static Logger& instance() {
        static Logger inst;  // 线程安全初始化（C++11 保证）
        return inst;
    }
    
    void log(const QString& msg);
    
private:
    Logger() = default;
};

// constinit 保证全局实例一定在 main 之前初始化
// ❌ 错误：constinit 不能用于非 constexpr 初始化的引用
// constinit Logger& g_logger = Logger::instance();  // 编译错误！

// ✅ 正确：使用 constinit 修饰全局指针，指向单例
inline Logger& getLogger() {
    static Logger inst;  // C++11 保证线程安全的延迟初始化
    return inst;
}

// 或者使用 constinit 修饰全局常量
constinit Logger* g_logger_ptr = &getLogger();  // 指针本身是常量初始化的

5. 编译期字符串处理（C++20）

C++20 引入了编译期字符串字面量模板参数，使得编译期字符串处理成为可能：

// 编译期字符串模板参数
template<size_t N>
struct StringLiteral {
    char data[N];
    
    constexpr StringLiteral(const char (&str)[N]) {
        std::copy_n(str, N, data);
    }
    
    constexpr auto size() const { return N - 1; }
    constexpr char operator[](size_t i) const { return data[i]; }
};

// 编译期字符串拼接
template<size_t A, size_t B>
constexpr auto concat(const char (&a)[A], const char (&b)[B]) {
    StringLiteral<A + B - 1> result{};
    // 复制第一个字符串（不包括末尾的 '\0'）
    for (size_t i = 0; i < A - 1; ++i) {
        result.data[i] = a[i];
    }
    // 复制第二个字符串（包括末尾的 '\0'）
    for (size_t i = 0; i < B; ++i) {
        result.data[A - 1 + i] = b[i];
    }
    return result;
}

// 使用
constexpr auto VERSION = concat("App v", "2.0");
static_assert(VERSION.size() == 7);  // 编译期断言
static_assert(VERSION.data[0] == 'A');  // 编译期验证

Qt 场景：编译期信号槽地址验证

template<StringLiteral Signal, StringLiteral Slot>
class AutoConnect {
public:
    template<typename T>
    static void connect(T* obj) {
        // 编译期验证信号槽存在性
        constexpr auto signalHash = hash_string(Signal);
        constexpr auto slotHash = hash_string(Slot);
        // 运行时实际连接
        QObject::connect(obj, Signal.data, obj, Slot.data);
    }
};

// 使用
struct MyWidget : QWidget {
    Q_SIGNAL void dataChanged(const QString&);
    Q_SLOT void onDataChanged(const QString&) {}
};

AutoConnect<"dataChanged", "onDataChanged">::connect(widget);

代码实战

实战 1：编译期计算 Qt 坐标转换系数

// 场景：屏幕坐标到逻辑坐标的缩放因子，编译期确定
class ScreenConfig {
    static constexpr double DPI = 96.0;  // 标准 DPI
    static constexpr double SCALE_FACTOR = DPI / 72.0;
    
    // 编译期计算逻辑尺寸
    template<size_t Width, size_t Height>
    static constexpr auto logical_size() {
        return std::tuple{
            static_cast<int>(Width / SCALE_FACTOR),
            static_cast<int>(Height / SCALE_FACTOR)
        };
    }
    
public:
    // UI 常用尺寸，编译期计算
    static constexpr auto BUTTON_SIZE = logical_size<120, 36>();
    static constexpr auto ICON_SIZE = logical_size<24, 24>();
    static constexpr auto DIALOG_SIZE = logical_size<400, 300>();
};

// 使用：编译期确定大小，零运行时开销
QPushButton* btn = new QPushButton();
btn->setFixedSize(std::get<0>(ScreenConfig::BUTTON_SIZE),
                  std::get<1>(ScreenConfig::BUTTON_SIZE));

实战 2：编译期类型列表与元组展开

// 编译期类型列表
template<typename... Types>
struct TypeList {
    static constexpr size_t size = sizeof...(Types);
};

template<typename List, size_t Index>
struct TypeAt;

// 特化：递归基（Index == 0）
template<typename Head, typename... Tail>
struct TypeAt<TypeList<Head, Tail...>, 0> {
    using type = Head;
};

// 特化：递归步进（Index > 0）
template<typename Head, typename... Tail, size_t Index>
struct TypeAt<TypeList<Head, Tail...>, Index> {
    static_assert(Index < sizeof...(Tail) + 1, "Index out of bounds");
    using type = typename TypeAt<TypeList<Tail...>, Index - 1>::type;
};

// 特化：空列表访问 → 编译错误
template<size_t Index>
struct TypeAt<TypeList<>, Index> {
    // 空列表没有类型，任何访问都是错误的
    static_assert(Index < 0, "Cannot access element of empty TypeList");
};

// 编译期查找类型
template<typename List, typename T, size_t Index = 0>
struct IndexOf;

// 递归基：找到
template<typename T, size_t Index, typename... Rest>
struct IndexOf<TypeList<T, Rest...>, T, Index> : std::integral_constant<size_t, Index> {};

// 递归步进：不匹配，继续找
template<typename U, size_t Index, typename Head, typename... Rest>
struct IndexOf<TypeList<Head, Rest...>, U, Index> 
    : IndexOf<TypeList<Rest...>, U, Index + 1> {};

// 使用
using MyTypes = TypeList<int, double, QString, std::vector<int>>;
static_assert(std::is_same_v<TypeAt<MyTypes, 2>::type, QString>);  // ✅ 编译期验证
static_assert(IndexOf<MyTypes, double>::value == 1);  // ✅ 编译期求值

实战 3：consteval 打造类型安全的信号连接

// 编译期信号槽元数据
template<StringLiteral Signal, StringLiteral Slot>
struct SignalSlot {
    static constexpr auto signal = Signal;
    static constexpr auto slot = Slot;
};

// 使用模板参数自动连接
template<typename Widget, SignalSlot Sig>
class AutoConnector {
public:
   static void connect(Widget* w) {
    // C++20：在 consteval 函数中完成编译期验证
    // 注意：consteval 不能用于局部函数声明！
    // 正确方式：将验证放在模板参数或 static_assert 中
    static_assert(Sig.signal.size() > 0, "Signal name cannot be empty");
    static_assert(Sig.slot.size() > 0, "Slot name cannot be empty");
    
    // 运行时连接（注意：需要实际的函数指针，不能只传字符串名）
    // 更可靠的方式：在模板参数中使用成员函数指针
    QObject::connect(
        w, Sig.signal.data,  // ⚠️ 仅当 Sig.signal 是 constexpr 字符串
        w, Sig.slot.data
    );
}
};

// 定义可用的信号槽对
using ButtonClicks = SignalSlot<"clicked()", "onClicked()">;
using SliderMoves = SignalSlot<"valueChanged(int)", "onValueChanged(int)">;
using TextChanges = SignalSlot<"textChanged(const QString&)", "onTextChanged(const QString&)">;

// 使用
class MyWidget : public QWidget {
    Q_OBJECT
    QPushButton* m_btn;
    QSlider* m_slider;
    QLineEdit* m_edit;
    
public:
    MyWidget() {
        AutoConnector<QPushButton, ButtonClicks>::connect(m_btn);
        AutoConnector<QSlider, SliderMoves>::connect(m_slider);
        AutoConnector<QLineEdit, TextChanges>::connect(m_edit);
    }
    
private slots:
    void onClicked() { /* ... */ }
    void onValueChanged(int val) { /* ... */ }
    void onTextChanged(const QString&) { /* ... */ }
};

实战 4：C++23 constexpr vector 实现配置表

// C++23：编译期配置表
constexpr auto build_config_table() {
    std::vector<std::pair<const char*, int>> table;
    
    table.emplace_back("DEBUG", 0);
    table.emplace_back("INFO", 1);
    table.emplace_back("WARNING", 2);
    table.emplace_back("ERROR", 3);
    
    return table;
}

// 编译期获取配置值
consteval int lookup_level(const char* name) {
    auto table = build_config_table();
    for (const auto& [key, value] : table) {
        // 手动实现编译期字符串比较，因为 std::strcmp 不是 constexpr
        const char* p1 = key;
        const char* p2 = name;
        while (*p1 && *p2 && *p1 == *p2) { ++p1; ++p2; }
        if (*p1 == *p2) return value;
    }
    return -1;  // 未找到
}

static_assert(lookup_level("WARNING") == 2);  // ✅ 编译期验证

常见陷阱与最佳实践

陷阱 1：constexpr 函数中使用非 constexpr 操作

// ❌ 危险：std::string 不是 constexpr
constexpr int bad_hash(const std::string& s) {  // 编译错误
    return std::hash<std::string>{}(s);
}

// ✅ 正确：使用编译期可用的类型
constexpr int good_hash(const char* s) {
    int h = 0;
    while (*s) {
        h = h * 31 + *s++;
    }
    return h;
}

陷阱 2：constexpr 构造函数中的未定义行为

// ❌ 危险：除零是未定义行为，constexpr 中不允许
constexpr int bad_division(int a, int b) {
    return a / b;  // 如果 b == 0，整个调用都是 UB
}

// ✅ 正确：手动检查
constexpr int safe_division(int a, int b) {
    return b != 0 ? a / b : 0;  // 避免 UB
}

陷阱 3：constexpr 和虚函数

// C++20 允许 constexpr 虚函数，但有限制
struct Base {
    virtual constexpr int value() const { return 0; }  // ✅ C++20 支持
};

struct Derived : Base {
    constexpr int value() const override { return 42; }  // ✅ C++20 支持
};

// ✅ C++20 中可以在 constexpr 上下文中使用多态
constexpr int get_value() {
    Derived d;
    Base& b = d;
    return b.value();  // 编译期虚函数调用
}
static_assert(get_value() == 42);

// 但注意：如果编译期无法确定实际类型，虚函数调用会失败
// 例如通过基类指针访问但对象类型在运行时才确定

最佳实践总结

1. 优先 consteval：如果函数一定能编译期求值，用 consteval 强制它
2. 用 static_assert 验证：对关键编译期计算添加静态断言
3. 避免运行时类型信息：constexpr 中不能使用 typeid、dynamic_cast 等运行时特性
4. 考虑 C++20 std::is_constant_evaluated()：区分编译期和运行时上下文
5. Qt 中的编译期常量放头文件：让编译器有更多优化机会
6. 大型编译期计算考虑缓存：用 inline constexpr 避免重复计算

进阶思考

1. std::is_constant_evaluated()（C++20）：这个函数让你可以在 constexpr 函数中检测当前是否处于编译期求值上下文，用于实现"编译期高效、运行时也高效"的混合算法。

2. 编译期 vs 模板元编程：constexpr 计算比模板元编程更易读、更灵活，但模板元编程在类型层面的操作仍然不可替代。两者结合是现代 C++ 的最佳实践。

3. 编译器优化：现代编译器（GCC/Clang）能执行复杂的编译期计算，但计算量过大可能导致编译时间显著增加。合理使用是关键。

4. constinit 与 thread_local 的组合：用 constinit thread_local 声明线程局部的编译期常量，可以避免线程间共享的开销。

5. C++26 展望：std::format 的 constexpr 版本正在推进，未来可能实现"编译期格式化字符串验证"。

参考资源

• C++ Reference: constexpr specifier
• C++ Reference: consteval specifier (C++20)
• C++ Reference: constinit specifier (C++20)
• C++20 std::is_constant_evaluated()
• Compiler Explorer - 查看编译期计算汇编
• Fluent C++ - constexpr in C++20 and C++23