1
int n = getInput();      // 运行时读取
2
const int cn = n;        // OK：const 是"运行时不可修改"
3
// cn = 42;              // 错误：不能修改
4
// int arr[cn];          // 错误：数组大小必须是编译期常量
5

6
constexpr int ce = 42;   // 必须在编译期确定
7
int arr[ce];             // OK：ce 是编译期常量

1
const int a = 5;          // 编译期常量（字面量初始化）
2
constexpr int b = 5;      // 编译期常量，意图更明确
3

4
const int c = rand();     // 运行时 const，编译器不一定知道值
5
// constexpr int d = rand(); // 编译错误：rand() 不是 constexpr 函数
6

7
// 数组大小、模板参数、static_assert 只接受编译期常量
8
template<int N> struct Fixed {};
9
Fixed<a> fa;              // OK（a 是字面量初始化的 const）
10
Fixed<b> fb;              // OK
11
// Fixed<c> fc;           // 错误：c 是运行时值

1
constexpr int square(int x) {
2
    return x * x;
3
}

1
constexpr int a = square(5);   // 编译期计算，a = 25，嵌入二进制
2
int n = 5;
3
int b = square(n);             // n 是运行时值，退化为普通函数调用

1
// 传统做法：写两个重载，或者用 SFINAE
2
template<typename T>
3
std::enable_if_t<std::is_integral_v<T>, void>
4
process(T val) {
5
    std::cout << "Integer: " << val << "\n";
6
}
7

8
template<typename T>
9
std::enable_if_t<std::is_floating_point_v<T>, void>
10
process(T val) {
11
    std::cout << "Float: " << val << "\n";
12
}

1
#include <type_traits>
2
#include <iostream>
3

4
template<typename T>
5
void process(T val) {
6
    if constexpr (std::is_integral_v<T>) {
7
        // 这个分支只在 T 是整数时编译
8
        std::cout << "Integer: " << val << " (hex: " << std::hex << val << ")\n";
9
    } else if constexpr (std::is_floating_point_v<T>) {
10
        // 这个分支只在 T 是浮点数时编译
11
        std::cout << "Float: " << std::fixed << val << "\n";
12
    } else {
13
        // 其他类型
14
        std::cout << "Unknown type\n";
15
    }
16
}
17

18
int main() {
19
    process(42);         // Integer: 42 (hex: 2a)
20
    process(3.14f);      // Float: 3.140000
21
    process(std::string("hi"));  // Unknown type
22
    return 0;
23
}

1
#include <type_traits>
2

3
// 判断类型是否相同
4
static_assert(std::is_same_v<int, int>);          // true
5
static_assert(!std::is_same_v<int, float>);       // false
6

7
// 判断是否是整数类型
8
static_assert(std::is_integral_v<int>);           // true
9
static_assert(std::is_integral_v<long long>);     // true
10
static_assert(!std::is_integral_v<float>);        // false
11

12
// 判断是否是浮点类型
13
static_assert(std::is_floating_point_v<float>);   // true
14
static_assert(std::is_floating_point_v<double>);  // true
15

16
// 判断是否是指针
17
static_assert(std::is_pointer_v<int*>);           // true
18

19
// 移除 const 修饰
20
static_assert(std::is_same_v<
21
    std::remove_const_t<const int>,
22
    int
23
>);

1
// 标准库内部大概是这样
2
template<bool B>
3
struct BoolConstant {
4
    static constexpr bool value = B;
5
};
6

7
using TrueType  = BoolConstant<true>;
8
using FalseType = BoolConstant<false>;
9

10
template<typename T>
11
struct IsIntegral : FalseType {};   // 默认：不是整数
12

13
template<> struct IsIntegral<int>      : TrueType {};
14
template<> struct IsIntegral<long>     : TrueType {};
15
template<> struct IsIntegral<long long>: TrueType {};
16
// ... 等等

1
consteval int must_be_compile_time(int x) {
2
    return x * x;
3
}
4

5
constexpr int a = must_be_compile_time(5);   // OK：编译期求值，a = 25
6

7
int n = 5;
8
int b = must_be_compile_time(n);   // 编译错误！n 是运行时值，不允许退化

1
// 确保模板的 block size 配置是合法的
2
consteval int checked_block_size(int size) {
3
    if (size <= 0 || size > 1024 || size % 32 != 0) {
4
        throw "Invalid block size";  // consteval 函数里 throw 会变成编译错误
5
    }
6
    return size;
7
}
8

9
constexpr int BLOCK_SIZE = checked_block_size(128);  // OK
10
// constexpr int BAD = checked_block_size(100);      // 编译错误：100 不是 32 的倍数