C++ 模板进阶：特化、偏特化与非类型模板参数的深水区

#include <iostream>
using namespace std;
 
// 一个求"左 < 右"的通用函数模板
template<class T>
bool Less(T left, T right)
{
    return left < right;   // 傻瓜式泛化：直接比较两个值
}
 
int main()
{
    cout << Less(1, 2) << endl;       // T=int，比较两个 int，输出 1（表示 true）
    cout << Less('a', 'b') << endl;   // T=char，按 ASCII 比较，输出 1
    return 0;
}

#include <iostream>
using namespace std;
 
// 日期类：重载了 operator<，两个日期对象可以直接比较大小
class Date
{
public:
    Date(int y, int m, int d) : _y(y), _m(m), _d(d) {}
    // 先比年、再比月、最后比日，实现标准的日期比较
    bool operator<(const Date& other) const
    {
        if (_y != other._y) return _y < other._y;
        if (_m != other._m) return _m < other._m;
        return _d < other._d;
    }
    int _y, _m, _d;   // 课程示例简化：用公有成员，实际工程会用 get 方法
};
 
// 通用的小于比较函数模板
template<class T>
bool Less(T left, T right)
{
    return left < right;   // 直接比较两个值
}
 
int main()
{
    Date d1(2022, 7, 7);
    Date d2(2022, 7, 8);
    cout << Less(d1, d2) << endl;   // 比较两个日期对象，输出 1，正确
 
    Date* p1 = &d1;
    Date* p2 = &d2;
    cout << Less(p1, p2) << endl;   // 输出 0（false）？逻辑上 d1 明明小于 d2！
    return 0;
}

#include <iostream>
using namespace std;
 
class Date
{
public:
    Date(int y, int m, int d) : _y(y), _m(m), _d(d) {}
    bool operator<(const Date& other) const
    {
        if (_y != other._y) return _y < other._y;
        if (_m != other._m) return _m < other._m;
        return _d < other._d;
    }
    int _y, _m, _d;
};
 
// 通用的小于比较函数模板
template<class T>
bool Less(T left, T right)
{
    return left < right;   // 通用逻辑：直接比"值"
}
 
// 函数模板的全特化：专门处理 Date*，比较指针指向的日期对象
template<>
bool Less<Date*>(Date* left, Date* right)
{
    return *left < *right;   // 解引用后再比较
}
 
int main()
{
    Date d1(2022, 7, 7);
    Date d2(2022, 7, 8);
 
    cout << Less(d1, d2) << endl;   // T 推导为 Date，走通用模板，输出 1
    Date* p1 = &d1;
    Date* p2 = &d2;
    cout << Less(p1, p2) << endl;   // 命中特化版本，解引用比较，输出 1，正确！
    return 0;
}

// 想对"任意指针类型"做特化 —— 函数模板不支持！
// 下面这行是错误写法：
// template<class T> bool Less<T*>(T* left, T* right) { return *left < *right; }
// 语法层面：函数模板不能"偏特化"，你不能在参数表外再次限定 T* 这种部分条件

#include <iostream>
using namespace std;
 
// 重载版本一：任意类型，直接比数值
template<class T>
bool Less(T left, T right)
{
    return left < right;
}
 
// 重载版本二：任意"指针类型"（一个函数模板重载，不是特化）
// 调用时传指针，编译器会优先选"更专门"的这个版本
template<class T>
bool Less(T* left, T* right)
{
    return *left < *right;   // 对指针解引用后比较
}
 
int main()
{
    cout << Less(1, 2) << endl;         // 命中版本一：1 < 2
 
    int a = 10, b = 20;
    int* pa = &a;
    int* pb = &b;
    cout << Less(pa, pb) << endl;       // 命中版本二：解引用比较 10<20，输出 1
 
    char x = 'x', y = 'y';
    char* px = &x;
    char* py = &y;
    cout << Less(px, py) << endl;       // 也命中版本二：'x'(120) < 'y'(121)，输出 1
    return 0;
}

#include <iostream>
using namespace std;
 
// (A) 主模板：任意类型
template<class T>
void f(T)
{
    cout << "f(T) 主模板" << endl;
}
 
// (B) 对主模板 (A) 做全特化：T=int*
template<>
void f<int*>(int*)
{
    cout << "f(int*) 全特化" << endl;
}
 
// (C) 一个"更专门"的重载（指针形状），不是特化
template<class T>
void f(T*)
{
    cout << "f(T*) 重载" << endl;
}
 
int main()
{
    int x = 1;
    int* p = &x;
    f(p);      // 你能猜到这个调用走哪个版本吗？
    return 0;
}

#include <iostream>
using namespace std;
 
// 主模板（通用图纸）：两个类型参数
template<class T1, class T2>
class Data
{
public:
    Data() { cout << "Data<T1, T2>" << endl; }
private:
    T1 _d1;
    T2 _d2;
};
 
// 全特化：把 T1、T2 全部确定化为 int 和 char，形成一张"专用图纸"
template<>
class Data<int, char>
{
public:
    Data() { cout << "Data<int, char>" << endl; }
private:
    int  _d1;    // 成员类型也被确定成 int
    char _d2;    // 成员类型也被确定成 char
};
 
int main()
{
    Data<int, double> d1;   // 没有匹配的特化 → 走主模板 Data<T1,T2>
    Data<int, char>   d2;   // 精确命中 Data<int, char> → 走专用图纸
    return 0;
}

#include <iostream>
using namespace std;
 
// 主模板
template<class T>
struct Box
{
    static int count;                 // 主模板的静态成员（只是一个声明）
};
// 在主模板上给出静态成员的定义（每实例化一种 T 就各有一份）
template<class T>
int Box<T>::count = 0;
 
// 全特化：Box<double> 变成一张"全新的图纸"
template<>
struct Box<double>
{
    static int count;                 // 全特化里另行声明一个静态成员
};
template<>
int Box<double>::count = 88;          // 全特化的静态成员独立初始化为 88
 
int main()
{
    Box<int>::count = 1;
    Box<char>::count = 2;
    cout << Box<int>::count << " "
         << Box<char>::count << " "
         << Box<double>::count << endl;   // 输出：1 2 88
    return 0;
}

#include <iostream>
using namespace std;
 
// 主模板（通用图纸）
template<class T1, class T2>
class Data
{
public:
    Data() { cout << "Data<T1, T2>" << endl; }
private:
    T1 _d1;
    T2 _d2;
};
 
// 偏特化一：只把第二个参数固定为 int，第一个参数 T1 仍然自由
template<class T1>
class Data<T1, int>
{
public:
    Data() { cout << "Data<T1, int>" << endl; }
private:
    T1  _d1;
    int _d2;    // 第二个成员也被固定成 int
};
 
int main()
{
    Data<double, int> d1;   // T1=double,T2=int → 命中偏特化 Data<T1,int>
    Data<int, double> d2;   // 没有符合条件组合 → 走主模板
    return 0;
}

#include <iostream>
using namespace std;
 
// 主模板（通用图纸）：两个类型参数
template<class T1, class T2>
class Data
{
public:
    Data() { cout << "Data<T1, T2>" << endl; }
private:
    T1 _d1;
    T2 _d2;
};
 
// 偏特化（方向二·指针）：两个参数都限制为"指针"形状
template<typename T1, typename T2>
class Data<T1*, T2*>
{
public:
    Data() { cout << "Data<T1*, T2*>" << endl; }
private:
    T1 _d1;   // 这里存的是 T1、T2 本身（注意不是指针指向的内容）
    T2 _d2;
};
 
// 偏特化（方向二·引用）：两个参数都限制为"引用"形状
template<typename T1, typename T2>
class Data<T1&, T2&>
{
public:
    // 引用的偏特化需要绑定引用成员，所以提供了初始化列表构造函数
    Data(const T1& d1, const T2& d2) : _d1(d1), _d2(d2)
    {
        cout << "Data<T1&, T2&>" << endl;
    }
private:
    const T1& _d1;   // 引用成员必须绑定，不能默认构造
    const T2& _d2;
};
 
int main()
{
    Data<double, int> d1;      // 普通类型 → 走主模板 Data<T1,T2>
    Data<int, double> d2;      // 普通类型 → 走主模板
 
    Data<int*, int*> d3;       // 两个都是指针 → 命中 Data<T1*, T2*>
 
    int a = 1, b = 2;
    Data<int&, int&> d4(a, b); // 两个都是引用 → 命中 Data<T1&, T2&>
    return 0;
}

#include <iostream>
using namespace std;
 
// 主模板
template<class T>
struct X
{
    void go() { cout << "普通类型" << endl; }
};
 
// 形状·指针
template<class T>
struct X<T*>
{
    void go() { cout << "指针" << endl; }
};
 
// 形状·const 指针
template<class T>
struct X<const T*>
{
    void go() { cout << "const 指针" << endl; }
};
 
// 形状·数组（长度写成元素个数 N，可不指定具体大小）
template<class T, size_t N>
struct X<T[N]>
{
    void go() { cout << "数组" << endl; }
};
 
int main()
{
    X<int>      a; a.go();    // 普通类型
    X<int*>     b; b.go();    // 指针
    int v = 1;
    const int*  pc = &v;
    X<decltype(pc)> c; c.go();   // const 指针
    int arr[5];
    X<decltype(arr)> d; d.go();  // 数组
    return 0;
}

#include <iostream>
using namespace std;
 
template<class T1, class T2>
class Data
{
public:
    Data() { cout << "主模板" << endl; }
};
 
template<class T1>            // 偏特化：把第二个参数定死为 int
class Data<T1, int>
{
public:
    Data() { cout << "偏特化 Data<T1,int>" << endl; }
};
 
template<>                    // 全特化：全部定死
class Data<int, int>
{
public:
    Data() { cout << "全特化 Data<int,int>" << endl; }
};
 
int main()
{
    Data<double, int> d1;   // 命中偏特化（唯一贴合的）
    Data<int, int>    d2;   // 主模板、偏特化、全特化都能匹配 → 全特化优先
    Data<double, long> d3;  // 都不满足 → 走主模板
    return 0;
}

#include <iostream>
using namespace std;
 
// 类型形参 T + 非类型形参 N（默认 10）：一个定长的静态数组模板
template<class T, size_t N = 10>
class StaticArray
{
public:
    size_t size() const { return N; }      // N 在模板内部就是一个编译期常量
    T& operator[](size_t index) { return _arr[index]; }          // 可写下标访问
    const T& operator[](size_t index) const { return _arr[index]; } // 只读下标访问
private:
    T _arr[N];   // 用非类型参数 N 直接定义定长数组
};
 
int main()
{
    StaticArray<int, 20> a;      // T=int，N=20：一个容量 20 的 int 数组
    a[0] = 100;                  // 正常使用
    cout << a.size() << endl;    // 输出 20
 
    StaticArray<double> b;       // 没给 N，用默认值 10，T=double
    cout << b.size() << endl;    // 输出 10
    return 0;
}

constexpr int  CN = 20;           // constexpr：编译期常量，合格（C++11 起支持）
static const int M = 30;          // 文件作用域的 const 常量也能在编译期取值
 
StaticArray<int, CN> a1;          // √ 合法：N=20 是编译期常量
StaticArray<int, M>  a2;          // √ 合法：M 可在编译期求值
 
int n = get_dynamic_count();      // 运行期才确定数值的普通变量
// StaticArray<int, n> a3;        // × 错误！n 不是编译期常量，编译器会直接报错

#include <iostream>
using namespace std;
 
template<int N> struct Probe { static void show() { cout << N << endl; } };
 
int main()
{
    const int ok1 = 5;         // 常量初值 → 编译期常量 → 合法
    Probe<ok1>::show();        // 5
 
    int  runtime = 5;
    const int ok2 = runtime;   // 初值来自运行期变量 → 不是编译期常量
    // Probe<ok2>::show();     // × 错误：N 不是编译期常量表达式
 
    return 0;
}

#include <array>     // std::array：标准库中典型的"非类型参数模板"
#include <iostream>
using namespace std;
 
int main()
{
    // std::array<T, N> 的第一个参数是元素类型，第二个 N 就是非类型模板参数
    array<int, 5> nums = {1, 2, 3, 4, 5};   // 长度 5 写死在类型里
    cout << nums.size() << endl;            // 输出 5（编译期已知）
 
    // 非类型模板参数还能直接参与类型的区分，例如用作模板的"标签"
    // 这里演示：用 bool 作为非类型参数切分行为（常见于模板库设计）
    return 0;
}

#include <iostream>
using namespace std;
 
// 用非类型参数 N 做"编译期递归"
template<int N>
struct Factorial
{
    static const int value = N * Factorial<N - 1>::value;  // 拆 1 并递归
};
 
// 递归终止条件：全特化 N=0（再次见证最高的全特化优先级）
template<>
struct Factorial<0>
{
    static const int value = 1;
};
 
int main()
{
    cout << Factorial<5>::value << endl;   // 120，全程编译期算完，运行期直接取值
    return 0;
}

#include <iostream>
using namespace std;
 
enum class Shape { Circle, Square, Triangle };
 
// 用非类型参数 Shape 驱动编译期选择
template<Shape S>
struct ShapeInfo
{
    // 编译期三目运算：借此把"边数"算成编译期常量
    static const int sides = (S == Shape::Triangle) ? 3
                           : (S == Shape::Square)   ? 4
                           : 0;                       // Circle → 0
};
 
int main()
{
    cout << ShapeInfo<Shape::Triangle>::sides << endl;   // 3
    cout << ShapeInfo<Shape::Circle>::sides   << endl;   // 0
    return 0;
}

#include <iostream>
using namespace std;
 
constexpr int g_value = 42;      // 命名空间级常量，静态存储期、可作常量表达式
 
// 以"引用"作为非类型参数：绑定到 g_value 这个对象的地址
template<const int& R>
struct RefHolder
{
    int get() const { return R; }
};
 
int main()
{
    RefHolder<g_value> r;
    cout << r.get() << endl;     // 42
    return 0;
}

// 需要 C++20（例如 GCC/Clang 加 -std=c++20 编译）
#include <iostream>
using namespace std;
 
template<double Epsilon>              // C++20：浮点数终于可以当非类型参数
double within(double x, double target)
{
    return (x > target - Epsilon && x < target + Epsilon) ? 1.0 : 0.0;
}
 
struct Point { int x; int y; };       // 字面量类：所有成员 public，满足"结构类型"
template<Point P>                       // C++20：类对象也能当非类型参数
struct OriginRef
{
    static const int sum = P.x + P.y;
};
 
int main()
{
    cout << within<0.01>(1.005, 1.0) << endl;      // 1（在误差内）
    cout << OriginRef<Point{3, 4}>::sum << endl;   // 7（编译期求和）
    return 0;
}

#include <iostream>
using namespace std;
 
// 仿函数：一个重载了调用运算符 operator() 的类/结构体
struct Bigger
{
    // 重载 ()，让对象 Bigger 可以被当作"函数"来调用
    bool operator()(int a, int b) const
    {
        return a > b;   // 返回"a 是否大于 b"
    }
};
 
int main()
{
    Bigger cmp;              // 创建一个仿函数对象
    cout << cmp(3, 5) << endl;   // cmp(3,5) 实际调用 cmp.operator()(3,5) → 0（false）
    cout << cmp(9, 5) << endl;   // cmp(9,5) → 1（true）
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>    // for_each
using namespace std;
 
// 一个带"累加状态"的仿函数
struct Average
{
    long sum = 0;      // 成员状态
    int  count = 0;
    void operator()(int x)   // 注意：这里不写 const，因为要改成员
    {
        sum += x;
        ++count;
    }
};
 
int main()
{
    vector<int> v = {1, 2, 3, 4, 5};
 
    Average a;
    for_each(v.begin(), v.end(), a);       // 关键坑：for_each 是"按值"接收仿函数
    cout << a.sum << " " << a.count << endl;   // 输出：0 0 ！！外部 a 根本没被改
 
    // 正确姿势：for_each 会把"改完的仿函数"作为返回值还给你
    Average b = for_each(v.begin(), v.end(), Average());
    cout << b.sum << " " << b.count << endl;   // 输出：15 5
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
 
class Date
{
public:
    Date(int y, int m, int d) : _y(y), _m(m), _d(d) {}
    bool operator<(const Date& other) const   // 重载 <，日期可比大小
    {
        if (_y != other._y) return _y < other._y;
        if (_m != other._m) return _m < other._m;
        return _d < other._d;
    }
    int _y, _m, _d;
};
 
// 通用比较仿函数（主模板）
template<class T>
struct Less
{
    bool operator()(const T& x, const T& y) const
    {
        return x < y;   // 用 operator< 比较两个值
    }
};
 
// 类模板全特化：专门针对 Date*，比较指针指向的日期对象而非地址
template<>
struct Less<Date*>
{
    bool operator()(Date* x, Date* y) const
    {
        return *x < *y;   // 解引用后比较日期对象
    }
};
 
int main()
{
    Date d1(2022, 7, 7);   // 最小的日期
    Date d2(2022, 7, 6);   // 中间的日期
    Date d3(2022, 7, 8);   // 最大的日期
 
    vector<Date> v1;       // 存放日期对象序列
    v1.push_back(d1);
    v1.push_back(d2);
    v1.push_back(d3);
    sort(v1.begin(), v1.end(), Less<Date>());  // 按日期升序排，结果正确
 
    vector<Date*> v2;      // 存放日期指针序列
    v2.push_back(&d1);
    v2.push_back(&d2);
    v2.push_back(&d3);
    // 若用 Less<Date*> 的通用版本，sort 会按指针地址排，结果错误；
    // 但因为特化了 Less<Date*>，sort 会按"指针指向的日期"排，结果正确
    sort(v2.begin(), v2.end(), Less<Date*>());
 
    for (size_t i = 0; i < v2.size(); ++i)
        cout << v2[i]->_y << "-" << v2[i]->_m << "-" << v2[i]->_d << endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>   // std::greater
using namespace std;
 
int main()
{
    vector<int> v = {5, 1, 4, 2, 3};
    sort(v.begin(), v.end(), greater<int>());   // 降序
    for (int x : v) cout << x << " ";
    cout << endl;                                // 输出：5 4 3 2 1
    return 0;
}

#include <iostream>
#include <queue>
#include <vector>
using namespace std;
 
// 自定义"优先级"比较器：返回 a>b 表示 a 的优先权更低，让元素小的先出队 → 小根堆
struct MinFirst
{
    bool operator()(int a, int b) const { return a > b; }
};
 
int main()
{
    priority_queue<int, vector<int>, MinFirst> pq;   // 第三个模板参数就是仿函数
    pq.push(30);
    pq.push(10);
    pq.push(20);
    while (!pq.empty())
    {
        cout << pq.top() << " ";   // 每次取"优先级最高"（这里最小）的
        pq.pop();
    }
    cout << endl;                  // 输出：10 20 30
    return 0;
}

#include <iostream>
#include <type_traits>   // std::is_integral
using namespace std;
 
int main()
{
    cout << boolalpha;   // 让 true/false 打印成 true/false，而不是 1/0
    cout << is_integral<int>::value << endl;      // true
    cout << is_integral<double>::value << endl;   // false
    cout << is_pointer<int*>::value << endl;      // true
    cout << is_same<int, int>::value << endl;     // true
    return 0;
}

// 文件 a.h —— 只放模板声明
template<class T>
T Add(const T& left, const T& right);
 
// 文件 a.cpp —— 放模板定义
template<class T>
T Add(const T& left, const T& right)
{
    return left + right;
}
 
// 文件 main.cpp —— 调用方
#include "a.h"
int main()
{
    Add(1, 2);          // 试图实例化 Add<int>
    Add(1.0, 2.0);      // 试图实例化 Add<double>
    return 0;
}

// 推荐：a.hpp —— 声明与定义放一起（或干脆放 .h）
template<class T>
T Add(const T& left, const T& right)
{
    return left + right;   // 定义和声明一起提供
}
 
// 其它 .cpp 只要 #include "a.hpp" 即可正常使用、自动实例化

// ---- head.hpp：仍然宏包含全部定义（工程默认姿势）----
template<class T>
T Add(const T& a, const T& b) { return a + b; }
 
// ---- impl.cpp：这里"显式实例化"产生唯一的机器码 ----
#include "head.hpp"
template int    Add<int>(const int&, const int&);   // 生成 Add<int> 代码（本 TU 完成）
template double Add<double>(const double&, const double&);   // 生成 Add<double> 代码

// ---- other.cpp：这里用 extern template 声明"别在我这份里再生一份" ----
#include "head.hpp"
extern template int    Add<int>(const int&, const int&);    // 只是声明：定义在别处
extern template double Add<double>(const double&, const double&);