1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

#include <iostream>

// 模板元编程：程序在编译期间执行计算
// 这不是运行时代码，而是编译器生成代码的依据
// 想象一下编译器是个计算器，你告诉它公式，它帮你算出结果

// 编译期计算阶乘 - 通用模板
// 这是一个递归模板：Factorial<5> = 5 * Factorial<4>
// 以此类推，直到 Factorial<0>
template<int N>
struct Factorial {
    // value 是一个编译期常量，由编译器在编译时计算
    static const int value = N * Factorial<N - 1>::value;
};

// 特化基例 - 递归的终点
// 当 N == 0 时，返回 1，终止递归
template<>
struct Factorial<0> {
    static const int value = 1;
};

// C++14: constexpr变量 - 更现代的方式
// constexpr 关键字告诉编译器尽可能在编译期计算
constexpr int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

int main() {
    // 编译期计算！
    // 编译器在编译时就把 Factorial<5>::value 算出来了
    // 所以运行时直接打印常数，没有额外计算开销
    std::cout << "Factorial<5>::value = " << Factorial<5>::value << std::endl;  // 输出: 120
    std::cout << "Factorial<10>::value = " << Factorial<10>::value << std::endl;  // 输出: 3628800
    
    // C++14 constexpr也可以编译期计算
    // 这里数组大小在编译期就确定了：Factorial<6>::value = 720
    // 这是模板元编程的经典应用：用计算结果作为数组大小
    int arr[Factorial<6>::value];  // 编译期创建大小为720的数组！
    std::cout << "Array size: " << sizeof(arr) / sizeof(arr[0]) << std::endl;  // 输出: 720
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

#include <iostream>
#include <type_traits>
#include <vector>

// 类型traits：在编译期查询和转换类型
// 想象 traits 是一套类型检测工具包

int main() {
    // 查询类型属性
    // std::boolalpha 让 bool 值打印为 "true"/"false" 而不是 "1"/"0"
    std::cout << std::boolalpha;
    
    // is_integral: 检查类型是否是整型（int, char, short, long, bool 等）
    // 注意：bool 也是整型！这是C++的历史遗留
    std::cout << "std::is_integral<int>::value = " 
              << std::is_integral<int>::value << std::endl;  // 输出: true
    
    // is_floating_point: 检查是否是浮点类型（float, double, long double）
    std::cout << "std::is_floating_point<double>::value = " 
              << std::is_floating_point<double>::value << std::endl;  // 输出: true
    
    // is_pointer: 检查是否是指针类型
    std::cout << "std::is_pointer<int*>::value = " 
              << std::is_pointer<int*>::value << std::endl;  // 输出: true
    std::cout << "std::is_pointer<int>::value = " 
              << std::is_pointer<int>::value << std::endl;  // 输出: false
    
    // 类型转换traits - remove_const
    // std::remove_const<const int>::type 返回 int（去掉const）
    // std::is_same 用于比较两个类型是否相同
    std::cout << "std::is_same<int, typename std::remove_const<const int>::type>::value = "
              << std::is_same<int, typename std::remove_const<const int>::type>::value << std::endl;
    // 输出: true （因为去掉 const 后的 int 就是 int）
    
    // C++14 简化写法：_v 后缀
    // 不用写 ::value，直接用 _v 版本，更简洁
    std::cout << "std::is_integral_v<int> = " 
              << std::is_integral_v<int> << std::endl;  // 输出: true
    
    // conditional: 在编译期根据条件选择类型
    // 如果 sizeof(int) >= 4 为真，选择 int，否则选择 long
    // 这在编写跨平台代码时非常有用
    using T = std::conditional_t<sizeof(int) >= 4, int, long>;
    std::cout << "conditional_t selects: " << sizeof(T) << " bytes" << std::endl;
    // 输出: 4 bytes（在32位以上系统）
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

#include <iostream>
#include <type_traits>

// conditional_t：在编译期根据条件选择类型
// 这就像类型版的三元运算符：condition ? TypeA : TypeB

// 案例：根据类型选择"最宽"的数值类型
// 如果是浮点类型，选择 long double（最宽的浮点）
// 如果是整型，选择 long long（最宽的整型）
// 否则，保持原类型
template<typename T>
using Widest = std::conditional_t<std::is_floating_point_v<T>, 
                                   long double,  // 条件为真时选择这个
                                   std::conditional_t<std::is_integral_v<T>,
                                                      long long,  // 内层条件为真
                                                      T>>;         // 内层条件为假

// enable_if: 条件编译模板
// 如果条件不满足，SFINAE（替换失败不是错误）会让这个重载被忽略
// 这是实现"重载根据类型自动选择"的核心技术

// 整数版本的 square 函数
// 只有当 T 是整型时，这个模板才有效
template<typename T>
typename std::enable_if<std::is_integral_v<T>, T>::type
square(T value) {
    return value * value;
}

// 浮点数版本的 square 函数
// 只有当 T 是浮点型时，这个模板才有效
template<typename T>
typename std::enable_if<std::is_floating_point_v<T>, T>::type
square(T value) {
    return value * value;
}

int main() {
    // 测试 Widest 类型选择
    std::cout << "Widest<int> size = " << sizeof(Widest<int>) << std::endl;
    // 输出: 8（long long 的大小）
    
    std::cout << "Widest<double> size = " << sizeof(Widest<double>) << std::endl;
    // 输出: 16（long double 的大小，取决于平台）
    
    std::cout << "Widest<float> size = " << sizeof(Widest<float>) << std::endl;
    // 输出: 16（long double 的大小）
    
    // 测试 square 函数重载选择
    // 编译器自动选择正确的重载：
    // - square(5) 调用整数版本
    // - square(3.14) 调用浮点版本
    std::cout << "square(5) = " << square(5) << std::endl;  // 输出: 25
    std::cout << "square(3.14) = " << square(3.14) << std::endl;  // 输出: 9.8596
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

#include <iostream>
#include <type_traits>

// 编译期遍历类型列表
// TypeList 就像一个类型数组，可以存储任意数量的类型
template<typename... Args>
struct TypeList {
    // sizeof...(Args) 是参数包展开操作符
    // 它返回模板参数的数量
    static constexpr size_t size = sizeof...(Args);
};

// 编译期查找类型在列表中的位置
// IndexOf<T, Args...> 返回 T 在 Args... 中的索引
// 如果找不到，返回 static_cast<size_t>(-1)（即最大size_t值，表示未找到）

// 主模板：提供默认实现（基例）
// 如果所有特化都不匹配，就会使用这个主模板
// 注意：实际使用时，类型应该在列表中，否则会触发这个基例
template<typename T, typename U = T, typename... Args>
struct IndexOf {
    static constexpr size_t value = static_cast<size_t>(-1);  // 未找到，返回最大值
};

// 特化：第一个类型（U）就是要找的 T，命中！返回索引 0
template<typename T, typename... Args>
struct IndexOf<T, T, Args...> {
    // 找到了！位置是 0
    static constexpr size_t value = 0;
};

// 特化：第一个类型（U）不是我们要找的 T，递归检查剩余类型
// 模式匹配：IndexOf<T, U, Args...> 意味着 T 是目标类型，U 是列表第一个元素
// 如果 U != T，说明当前位置不对，递归往后续找
template<typename T, typename U, typename... Args>
struct IndexOf<T, U, Args...> {
    // 当前位置不是，索引 +1，继续往后找
    static constexpr size_t value = 1 + IndexOf<T, Args...>::value;
};

// 编译期检查类型是否在列表中
// 返回 true_type 或 false_type（布尔值在类型系统中的表示）
template<typename T, typename... Args>
struct Contains;

// 特化：空列表，不包含任何类型
template<typename T>
struct Contains<T> : std::false_type {};  // 继承自 false_type，value = false

// 特化：第一个类型就是我们要找的
template<typename T, typename... Args>
struct Contains<T, T, Args...> : std::true_type {};  // 继承自 true_type，value = true

// 特化：第一个类型不是，递归检查剩余
template<typename T, typename U, typename... Args>
struct Contains<T, U, Args...> : Contains<T, Args...> {};  // 继承父类的结果

int main() {
    // 定义一个类型列表
    using MyTypes = TypeList<int, double, char, float>;
    
    // 查询列表大小
    std::cout << "TypeList size: " << MyTypes::size << std::endl;  // 输出: 4
    
    // 查找类型位置
    // IndexOf<int, int, double, char>：第一个类型就是 int，位置 0
    std::cout << "IndexOf<int, int, double, char>: " 
              << IndexOf<int, int, double, char>::value << std::endl;  // 输出: 0
    
    // IndexOf<char, int, double, char>：第一个不是，递归找到位置 2
    std::cout << "IndexOf<char, int, double, char>: " 
              << IndexOf<char, int, double, char>::value << std::endl;  // 输出: 2
    
    // 检查类型是否在列表中
    std::cout << "Contains<int, int, double>: " 
              << Contains<int, int, double>::value << std::endl;  // 输出: 1（true）
    std::cout << "Contains<char, int, double>: " 
              << Contains<char, int, double>::value << std::endl;  // 输出: 0（false）
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

#include <iostream>
#include <vector>

// 表达式模板：延迟求值，避免临时对象
// 这是一个简化示例，展示表达式模板的核心原理

// 基础 Vec 类：存储数据的向量
template<typename T>
class Vec {
    T data_[3];  // 固定大小数组，简化实现
    
public:
    // 默认构造函数：初始化为 0
    Vec() { data_[0] = data_[1] = data_[2] = T{}; }
    
    // 带参构造函数
    Vec(T x, T y, T z) { data_[0] = x; data_[1] = y; data_[2] = z; }
    
    // const 版本下标访问
    const T& operator[](size_t i) const { return data_[i]; }
    
    // 非 const 版本下标访问
    T& operator[](size_t i) { return data_[i]; }
};

// VecExpr：表达式模板包装器
// 它不存储数据，而是存储一个"表达式"的引用
// 当你访问它的下标时，它会委托给内部的表达式去计算
template<typename Expr>
class VecExpr {
    const Expr& expr_;  // 存储表达式的引用
    
public:
    VecExpr(const Expr& e) : expr_(e) {}
    
    // 下标访问：返回表达式在该位置的结果
    const auto operator[](size_t i) const { return expr_[i]; }
};

// VecSum：表示两个 Vec 相加的表达式
template<typename T>
struct VecSum {
    const Vec<T>& a_;  // 引用，不拷贝
    const Vec<T>& b_;  // 引用，不拷贝
    
    // 重载下标操作符：返回对应位置的和
    T operator[](size_t i) const { return a_[i] + b_[i]; }
};

// 重载 + 操作符：返回表达式模板，而不是计算结果
template<typename T>
VecExpr<VecSum<T>> operator+(const Vec<T>& a, const Vec<T>& b) {
    // 返回一个表达式模板，包含两个 Vec 的引用
    // 此时还没有进行任何计算！
    return VecExpr<VecSum<T>>(VecSum<T>{a, b});
}

int main() {
    Vec<int> v1(1, 2, 3);
    Vec<int> v2(10, 20, 30);
    
    // v1 + v2 不执行加法，而是返回一个 VecExpr<VecSum<int>>
    // 这个表达式模板包含了对 v1 和 v2 的引用
    auto result = v1 + v2;  // 不立即计算，返回表达式模板
    
    // 当我们真正需要值的时候（通过下标访问），
    // 表达式模板才会计算出具体的数值
    std::cout << "result[0] = " << result[0] << std::endl;  // 实际计算时才求值
    std::cout << "result[1] = " << result[1] << std::endl;  // 输出: 22
    std::cout << "result[2] = " << result[2] << std::endl;  // 输出: 33
    
    return 0;
}

1
2
3
4
5

if constexpr (条件) {
    // 条件为 true 时编译这个分支
} else {
    // 条件为 false 时编译这个分支
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

#include <iostream>
#include <type_traits>
#include <vector>

// constexpr if：编译期if，在编译期选择代码分支
// 这个 if 是在编译期求值的，false 的分支会被完全丢弃

// 示例1：根据类型返回不同值
template<typename T>
auto getValue(T value) {
    // 如果 T 是整型，执行第一个分支
    // 否则，执行 else 分支
    if constexpr (std::is_integral_v<T>) {
        return value * 2;  // 只编译这个分支
    } else {
        return value;  // 其他分支被丢弃
    }
    // 编译器保证只有一个分支被编译
}

// 示例2：多重条件判断
template<typename T>
auto describe() {
    if constexpr (std::is_pointer_v<T>) {
        // 如果是指针类型
        return "pointer type";
    } else if constexpr (std::is_reference_v<T>) {
        // 如果是引用类型
        return "reference type";
    } else if constexpr (std::is_array_v<T>) {
        // 如果是数组类型
        return "array type";
    } else {
        // 其他类型
        return "other type";
    }
}

// 示例3：使用 std::is_integral 检查类型是否支持整数运算
// 注意：is_invocable_v<T, int> 检查的是"T本身是否可调用"，而非"T + int"是否有定义
// 这里用 is_integral_v 来演示整数类型的编译期判断
template<typename T>
auto process(T value) {
    // 用 is_integral 检查 T 是否是整数类型
    // 如果是整数类型，返回 value + 1；否则原样返回
    if constexpr (std::is_integral_v<T>) {
        // 如果 T 是整型，执行这个分支
        return value + 1;
    } else {
        return value;
    }
}

int main() {
    // 测试 getValue
    std::cout << "getValue(5) = " << getValue(5) << std::endl;  // 输出: 10
    std::cout << "getValue(3.14) = " << getValue(3.14) << std::endl;  // 输出: 3.14
    
    // 测试 describe
    std::cout << "describe<int*>() = " << describe<int*>() << std::endl;
    std::cout << "describe<int&>() = " << describe<int&>() << std::endl;
    std::cout << "describe<int>() = " << describe<int>() << std::endl;
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#include <iostream>

// C++23: consteval if
// 用于在consteval函数内部根据编译期/运行时条件选择分支

// consteval 函数：必须编译期求值
consteval int power(int base, int exp) {
    int result = 1;
    for (int i = 0; i < exp; ++i) {
        result *= base;
    }
    return result;
}

int main() {
    // if consteval：判断是否在常量求值上下文中
    
    // 如果这段代码在编译期求值，执行 then 分支
    // 如果在运行时执行，执行 else 分支
    if consteval {
        std::cout << "Running in constant evaluation context" << std::endl;
    } else {
        std::cout << "Running at runtime" << std::endl;
    }
    
    // constexpr 变量：在编译期计算
    constexpr int p2 = power(2, 10);  // 编译期计算
    std::cout << "2^10 = " << p2 << std::endl;  // 输出: 1024
    
    // 注意：如果这样调用：
    // int n = 5;
    // auto runtime_value = power(2, n);
    // 这会报错，因为 n 不是常量，power 必须是 consteval
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

#include <iostream>
#include <array>

// C++23: constexpr for (compile-time iteration)
// 编译期循环终于可以写成更像普通 for 循环的样子了！

// 使用模板参数包展开创建数组
// C++17 支持参数包展开，可以直接在初始化列表中使用 values...
template<auto... values>
constexpr auto make_array_v1() {
    // 使用初始化列表和参数包展开
    return std::array<int, sizeof...(values)>{values...};
}

// C++17: 使用模板参数包展开创建数组
// 参数包展开 `values...` 将所有传入的值展开为初始化列表
template<auto... values>
constexpr auto make_array() {
    // 将参数包展开为数组字面量
    // 这是 C++17 的标准语法，无需特殊扩展
    return std::array<int, sizeof...(values)>{values...};
}

int main() {
    // C++23 允许在 constexpr 上下文中使用更复杂的语句
    
    // 编译期创建并初始化数组
    constexpr auto arr = make_array<1, 2, 3, 4, 5>();
    
    // 静态断言：编译期验证
    static_assert(arr.size() == 5);
    static_assert(arr[0] == 1);
    static_assert(arr[4] == 5);
    
    // 运行时也可以使用（数组内容在编译期已确定）
    std::cout << "Array size: " << arr.size() << std::endl;  // 输出: 5
    std::cout << "Array elements: ";
    for (auto x : arr) {
        std::cout << x << " ";  // 输出: 1 2 3 4 5
    }
    std::cout << std::endl;
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include <iostream>
#include <type_traits>

// 变量模板：模板的变量形式
// 语法：template<typename T> constexpr T var_name = ...;

// 模板化的 is_signed 变量
// 使用时直接写 is_signed_v<int>，不用 is_signed<int>::value
template<typename T>
inline constexpr bool is_signed_v = std::is_signed<T>::value;

// 模板化的 sizeof 变量
// 再也不用写 sizeof(T) 了！
template<typename T>
inline constexpr size_t type_size_v = sizeof(T);

// 模板化的圆周率常量
// 为不同类型提供合适的 pi 值
// 注意：浮点字面量默认是 double，需要强制转换
template<typename T>
inline constexpr T pi = T(3.14159265358979323846);

int main() {
    std::cout << std::boolalpha;
    
    // 使用变量模板
    std::cout << "is_signed_v<int> = " << is_signed_v<int> << std::endl;  // 输出: true
    std::cout << "is_signed_v<unsigned> = " << is_signed_v<unsigned> << std::endl;  // 输出: false
    
    std::cout << "type_size_v<double> = " << type_size_v<double> << std::endl;  // 输出: 8
    
    // 使用 pi 变量模板
    // 自动获得对应类型的 pi 值
    std::cout << "pi<double> = " << pi<double> << std::endl;  // 输出: 3.14159
    std::cout << "pi<float> = " << pi<float> << std::endl;    // 输出: 3.14159
    
    return 0;
}

1
2
3
4
5
6
7

// 一元折叠
(... op pack)     // 左折叠：(((pack1 op pack2) op pack3) op ... op packN)
(pack op ...)      // 右折叠：(pack1 op (pack2 op (... op packN)))

// 二元折叠
(init op ... op pack)  // 左折叠：(init op pack1 op pack2 op ... op packN)
(pack op ... op init)  // 右折叠：(pack1 op pack2 op ... op packN op init)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

#include <iostream>

// C++26（草案）: 折叠表达式改进
// 包括约束排序等

// 可变参数模板 sum 函数
// 使用一元左折叠：(... + args) 展开为 ((args1 + args2) + args3) ...
template<typename... Args>
auto sum(Args... args) {
    // C++17 一元折叠表达式
    // 编译器自动将 args... 展开为累加表达式
    return (... + args);
}

// 使用二元折叠（带初始值）
template<typename T, typename... Args>
auto sum_with_initial(T init, Args... args) {
    // 二元左折叠：(0 + args1 + args2 + ...)
    return (init + ... + args);
}

// C++26（草案）: 折叠表达式与 variadic auto
// C++26 允许在泛型 lambda 和模板参数中使用 variadic auto
// 以下示例展示使用 variadic auto（非类型模板参数包）的折叠表达式
template<auto... values>
constexpr auto make_sum() {
    // C++26 支持 auto... 作为非类型模板参数包
    // 使用折叠表达式对所有参数求和
    return (... + values);
}

int main() {
    // 测试 sum
    std::cout << "sum(1, 2, 3, 4, 5) = " << sum(1, 2, 3, 4, 5) << std::endl;  // 输出: 15
    
    // 测试带初始值的 sum
    std::cout << "sum_with_initial(100, 1, 2, 3) = " << sum_with_initial(100, 1, 2, 3) << std::endl;
    // 输出: 106
    
    // 折叠表达式的其他应用
    // 打印所有参数：
    // ((std::cout << args) << ... << std::endl);
    
    // 检查所有条件都满足：
    // (true && ... && conditions)
    
    return 0;
}