模板基础

// ========== 没有模板的世界：类型爆炸 ==========
 
// 针对 int 类型的 max 函数
int maxInt(int a, int b) {        // 接受两个 int 参数
    return (a > b) ? a : b;       // 返回较大值
}
 
// 针对 double 类型的 max 函数
double maxDouble(double a, double b) {  // 接受两个 double 参数
    return (a > b) ? a : b;             // 逻辑完全相同，只是类型不同
}
 
// 针对 std::string 类型的 max 函数
std::string maxString(std::string a, std::string b) {  // 又一份拷贝
    return (a > b) ? a : b;                             // 依然是同样的逻辑
}
 
// 如果还有 float, long, char... 每个类型都要写一份？

// ========== 函数模板的基本语法 ==========
 
// template  —— 模板声明的开始
// <typename T>    —— 模板参数列表，T 是一个类型参数（type parameter）
// typename 也可以替换成 class，两者在此处完全等价
template <typename T>
T myMax(T a, T b) {               // T 在此处充当一个"占位类型"
    return (a > b) ? a : b;       // 要求 T 类型必须支持 > 运算符
}
 
// 等价写法：使用 class 关键字
template <class T>                // class 和 typename 在模板参数中无区别
T myMax(T a, T b) {
    return (a > b) ? a : b;
}

#include <iostream>
#include <string>
 
template <typename T>
T myMax(T a, T b) {               // 模板函数：返回两者中的较大值
    return (a > b) ? a : b;
}
 
int main() {
    // ====== 隐式推导（Implicit Deduction）======
    // 编译器根据实参类型自动推导 T
    int result1 = myMax(10, 20);                 // T 被推导为 int
    double result2 = myMax(3.14, 2.72);          // T 被推导为 double
    std::string result3 = myMax(
        std::string("hello"),                    // T 被推导为 std::string
        std::string("world")
    );
 
    // ====== 显式指定（Explicit Specification）======
    // 在函数名后用 <> 手动指定模板参数
    double result4 = myMax<double>(10, 3.14);    // 显式指定 T = double
    // 此时 int 10 会被隐式转换为 double 10.0
 
    std::cout << result1 << std::endl;           // 输出 20
    std::cout << result2 << std::endl;           // 输出 3.14
    std::cout << result3 << std::endl;           // 输出 "world"（字典序更大）
    std::cout << result4 << std::endl;           // 输出 10（因为 10.0 > 3.14）
 
    return 0;
}

template <typename T>
T myMax(T a, T b) {
    return (a > b) ? a : b;
}
 
int main() {
    // ❌ 编译错误！a 推导出 T=int，b 推导出 T=double，产生歧义
    // auto result = myMax(10, 3.14);
 
    // ✅ 解决方案 1：显式指定模板参数
    auto r1 = myMax<double>(10, 3.14);   // 强制 T=double，10 隐式转换为 10.0
 
    // ✅ 解决方案 2：手动强制实参类型一致
    auto r2 = myMax(static_cast<double>(10), 3.14);  // 两个参数都是 double
 
    // ✅ 解决方案 3：使用两个模板参数（见下文）
    return 0;
}

#include <iostream>
 
// ========== 双模板参数：参数类型可以不同 ==========
template <typename T1, typename T2>
// 返回值类型使用 auto，让编译器根据三目运算符的结果自动推导（C++14 起）
auto myMax(T1 a, T2 b) {
    return (a > b) ? a : b;       // T1 和 T2 可以是不同类型
}                                  // 返回类型由编译器根据 ?: 表达式推导
 
int main() {
    auto result = myMax(10, 3.14); // T1=int, T2=double
    // 三目运算符 (int > double) ? int : double
    // 根据 C++ 的算术转换规则，结果类型为 double
    std::cout << result << std::endl;  // 输出 10（实际是 double 类型的 10.0）
 
    return 0;
}

// ========== C++11 兼容写法：尾置返回类型 ==========
template <typename T1, typename T2>
auto myMax(T1 a, T2 b) -> decltype((a > b) ? a : b) {
    // decltype 在编译期检查表达式 (a>b)?a:b 的类型，将其作为返回类型
    return (a > b) ? a : b;
}
 
// ========== 另一种方案：std::common_type ==========
#include <type_traits>  // 包含 std::common_type
 
template <typename T1, typename T2>
typename std::common_type<T1, T2>::type   // 求 T1 和 T2 的公共类型
myMax(T1 a, T2 b) {
    return (a > b) ? a : b;
}
// std::common_type<int, double>::type  →  double
// 它能找到两个类型都能安全转换到的"公共类型"

#include <iostream>
#include <array>
 
// ========== 非类型模板参数示例 ==========
// N 是一个非类型参数，它的类型是 int，值在编译期确定
template <typename T, int N>
T arraySum(const T (&arr)[N]) {   // 接受一个大小为 N 的 T 类型数组的引用
    T sum = T();                   // 值初始化，对于数值类型即为 0
    for (int i = 0; i < N; ++i) { // 遍历数组的每一个元素
        sum += arr[i];             // 累加到 sum 中
    }
    return sum;                    // 返回总和
}
 
int main() {
    int nums[] = {1, 2, 3, 4, 5};       // 编译器知道数组大小为 5
    double vals[] = {1.1, 2.2, 3.3};     // 编译器知道数组大小为 3
 
    // 编译器推导：T=int, N=5
    std::cout << arraySum(nums) << std::endl;   // 输出 15
 
    // 编译器推导：T=double, N=3
    std::cout << arraySum(vals) << std::endl;   // 输出 6.6
 
    return 0;
}

// ========== C++17: auto 非类型模板参数 ==========
template <auto N>                  // N 的类型由传入的值自动推导
void printValue() {
    std::cout << N << std::endl;   // 输出编译期常量 N 的值
}
 
int main() {
    printValue<42>();              // N 推导为 int 类型，值为 42
    printValue<'A'>();             // N 推导为 char 类型，值为 'A'
    printValue<true>();            // N 推导为 bool 类型，值为 true
    return 0;
}

#include <iostream>
 
template <typename T>
void greet(T value) {                     // 函数模板定义
    std::cout << "Value: " << value << std::endl;
}
 
// ========== 显式实例化声明 ==========
// 告诉编译器："请现在就为 int 类型生成 greet<int> 的代码"
template void greet<int>(int);            // 显式实例化 int 版本
 
// 也可以不写 <int>，让编译器从参数类型推导
template void greet(double);              // 显式实例化 double 版本
 
int main() {
    greet(42);            // 使用已显式实例化的 int 版本
    greet(3.14);          // 使用已显式实例化的 double 版本
    greet("hello");       // 隐式实例化 const char* 版本（首次使用时生成）
    return 0;
}

// ========== math_ops.h ==========
template <typename T>
T square(T x) {                    // 函数模板定义（在头文件中）
    return x * x;
}
 
// ========== math_ops.cpp ==========
#include "math_ops.h"
template int square<int>(int);     // 在此处集中进行显式实例化
template double square<double>(double);
 
// ========== main.cpp ==========
#include "math_ops.h"
extern template int square<int>(int);      // 阻止此翻译单元隐式实例化 int 版本
extern template double square<double>(double); // 阻止隐式实例化 double 版本
 
int main() {
    square(5);       // 不会在 main.cpp 中生成代码，链接时使用 math_ops.o 中的版本
    square(2.5);     // 同理
    return 0;
}

#include <iostream>
#include <cstring>
 
// ========== 重载 1：通用模板 ==========
template <typename T>
T myMax(T a, T b) {                        // 泛型版本：适用于大多数类型
    std::cout << "[Template Version] ";
    return (a > b) ? a : b;
}
 
// ========== 重载 2：普通函数（非模板） ==========
const char* myMax(const char* a, const char* b) {  // 针对 C 风格字符串的特化处理
    std::cout << "[Non-template Version] ";
    return (std::strcmp(a, b) > 0) ? a : b;         // 使用 strcmp 进行字典序比较
}                                                    // 而非比较指针地址
 
// ========== 重载 3：另一个模板 ==========
template <typename T>
T myMax(T a, T b, T c) {                   // 三参数版本
    std::cout << "[Three-arg Template] ";
    return myMax(myMax(a, b), c);           // 复用两参数版本
}
 
int main() {
    std::cout << myMax(10, 20) << std::endl;
    // 输出: [Template Version] 20
    // 匹配 template myMax(T, T)，T=int
 
    std::cout << myMax("apple", "banana") << std::endl;
    // 输出: [Non-template Version] banana
    // 普通函数完全匹配 (const char*, const char*)，优先于模板
 
    std::cout << myMax(1, 2, 3) << std::endl;
    // 输出: [Three-arg Template] [Template Version] [Template Version] 3
    // 匹配三参数模板
 
    std::cout << myMax<>("apple", "banana") << std::endl;
    // 输出: [Template Version] banana（或 apple，取决于指针值大小）
    // 空尖括号 <> 显式要求使用模板版本，此时比较的是指针地址！
    // ⚠️ 这可能不是你想要的行为
 
    return 0;
}

#include <iostream>
#include <functional>  // std::less, std::greater
 
// ========== 带默认模板参数的函数模板 ==========
// Compare 是第二个模板参数，默认值为 std::less<T>
template <typename T, typename Compare = std::less<T>>
T myMax(T a, T b, Compare comp = Compare()) {
    // comp 是一个可调用对象（callable），默认为 std::less<T> 的实例
    // std::less<T> 的 operator() 实现的是 a < b
    return comp(a, b) ? b : a;    // 如果 a < b，返回 b（较大值）
}
 
int main() {
    // 使用默认比较器 std::less<int>
    std::cout << myMax(10, 20) << std::endl;      // 输出 20
 
    // 显式传入 std::greater<int>，逻辑反转：返回较小值
    std::cout << myMax(10, 20, std::greater<int>()) << std::endl;  // 输出 10
 
    return 0;
}

// ========== 错误示范：模板定义放在 .cpp 中 ==========
 
// --- myMax.h ---
template <typename T>
T myMax(T a, T b);                // 仅声明，无定义
 
// --- myMax.cpp ---
#include "myMax.h"
template <typename T>
T myMax(T a, T b) {               // 定义在此
    return (a > b) ? a : b;
}
// 此翻译单元没有任何调用，所以不会实例化任何版本
 
// --- main.cpp ---
#include "myMax.h"
int main() {
    myMax(1, 2);   // 编译通过（声明可见），但链接失败！
    // ❌ Linker Error: undefined reference to `int myMax<int>(int, int)`
    // 因为编译 main.cpp 时看不到模板定义，无法实例化
    return 0;
}

// ========== 正确做法：模板定义放在头文件中 ==========
 
// --- myMax.h ---
template <typename T>
T myMax(T a, T b) {               // 声明 + 定义都在头文件中
    return (a > b) ? a : b;       // 每个 #include 此头文件的翻译单元都能看到完整定义
}
 
// --- main.cpp ---
#include "myMax.h"
int main() {
    myMax(1, 2);    // ✅ 编译器看到完整定义，可以实例化 myMax<int>
    return 0;
}

#include <iostream>
#include <type_traits>
 
// ========== SFINAE 基础示例 ==========
 
// 版本 1：仅当 T 是整数类型时启用
template <typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type
process(T value) {                         // 只有 T 是整型时此函数才"存在"
    std::cout << "Integer: " << value << std::endl;
    return value;
}
 
// 版本 2：仅当 T 是浮点类型时启用
template <typename T>
typename std::enable_if<std::is_floating_point<T>::value, T>::type
process(T value) {                         // 只有 T 是浮点型时此函数才"存在"
    std::cout << "Floating: " << value << std::endl;
    return value;
}
 
int main() {
    process(42);         // 匹配版本 1（int 是整型）
                         // 版本 2 替换失败 → SFINAE → 静默排除，不报错
 
    process(3.14);       // 匹配版本 2（double 是浮点型）
                         // 版本 1 替换失败 → SFINAE → 静默排除
 
    // process("hello"); // ❌ 两个版本都替换失败，没有可行候选，编译错误
    return 0;
}

template <typename T>
void foo(T a, T b) {}
 
int main() {
    // foo("abc", "abcd");  // ❌ 编译错误！
    // "abc" 的类型是 const char[4]，"abcd" 的类型是 const char[5]
    // T 不能同时是两个不同大小的数组类型
 
    // ✅ 解决方案：使用按引用传递，或者让参数类型退化
}
 
// 方案 A：传引用，保留数组类型
template <typename T, int N, int M>
void foo_ref(const T (&a)[N], const T (&b)[M]) {  // 两个数组可以不同大小
    // T=char, N=4, M=5
}
 
// 方案 B：传值，数组退化为指针
template <typename T>
void foo_decay(T a, T b) {}      // 按值传递时，数组退化为 const char*
// 但此时 foo_decay("abc", "abcd") 的 T 都推导为 const char*，可以编译

template <typename T>
const T& myMax(const T& a, const T& b) {  // 返回引用以避免拷贝
    return (a > b) ? a : b;
}
 
int main() {
    int x = 10, y = 20;
    const int& ref = myMax(x, y);  // ✅ 安全：ref 绑定到 y，y 仍然活着
 
    // ⚠️ 危险场景：
    const int& bad = myMax(42, 100);
    // 42 和 100 是临时对象（rvalue），函数结束后销毁
    // bad 成为悬垂引用（dangling reference）！
    // 使用 bad 是未定义行为（Undefined Behavior）
    return 0;
}

#include <iostream>
 
template <typename T>
void print(T value) {
    std::cout << "Template: " << value << std::endl;
}
 
void print(int value) {
    std::cout << "Non-template: " << value << std::endl;
}
 
int main() {
    print(42);
    print(3.14);
    print<>(42);
    return 0;
}

#include <iostream>  // 标准输入输出
#include <vector>    // 底层容器
#include <stdexcept> // 异常类
 
// template 关键字声明这是一个模板
// typename T 是模板类型参数，T 是占位符，代表任意类型
// 也可以写成 class T，在此处 typename 和 class 完全等价
template <typename T>
class Stack {
private:
    std::vector<T> elems_;  // 用 vector<T> 存储元素，T 被用作 vector 的模板实参
 
public:
    // 将元素压入栈顶
    // 参数类型为 const T&，接受任意类型 T 的常量引用
    void push(const T& elem) {
        elems_.push_back(elem);  // 委托给 vector 的 push_back
    }
 
    // 弹出栈顶元素
    void pop() {
        if (elems_.empty()) {                        // 空栈检查
            throw std::out_of_range("Stack::pop(): empty stack");  // 抛出异常
        }
        elems_.pop_back();  // 移除最后一个元素（即栈顶）
    }
 
    // 返回栈顶元素的常量引用
    // 返回类型为 const T&，与模板参数 T 关联
    const T& top() const {
        if (elems_.empty()) {                        // 空栈检查
            throw std::out_of_range("Stack::top(): empty stack");
        }
        return elems_.back();  // 返回最后一个元素的引用
    }
 
    // 判断栈是否为空
    bool empty() const {
        return elems_.empty();  // 委托给 vector 的 empty()
    }
 
    // 返回栈内元素个数
    std::size_t size() const {
        return elems_.size();   // 委托给 vector 的 size()
    }
};

int main() {
    Stack<int> intStack;         // 隐式实例化 Stack<int>，T = int
    Stack<std::string> strStack; // 隐式实例化 Stack<std::string>，T = std::string
 
    intStack.push(42);           // 调用 Stack<int>::push(const int&)
    intStack.push(17);           // 再次压入一个 int
    std::cout << intStack.top() << std::endl;  // 输出 17（栈顶）
    intStack.pop();              // 弹出 17
    std::cout << intStack.top() << std::endl;  // 输出 42
 
    strStack.push("hello");     // 调用 Stack<std::string>::push(const std::string&)
    strStack.push("world");     // 字符串字面量会隐式转换为 std::string
    std::cout << strStack.top() << std::endl;  // 输出 "world"
 
    return 0;
}

template <typename T>
class Wrapper {
public:
    T value_;                          // 存储一个 T 类型的值
 
    void print() {                     // 打印值
        std::cout << value_ << std::endl;  // 要求 T 支持 operator<<
    }
 
    void increment() {                 // 自增
        value_ += 1;                   // 要求 T 支持 operator+=
    }
};
 
int main() {
    Wrapper<std::string> w{"hello"};   // 实例化 Wrapper<std::string>
    w.print();                         // ✅ OK，std::string 支持 <<
    // w.increment();                  // ❌ 若取消注释则编译失败：string 不支持 += 1
    // 但只要不调用 increment()，整个程序就能编译通过！
    return 0;
}

// 显式实例化声明（通常放在 .cpp 文件中）
template class Stack<int>;           // 强制编译器生成 Stack<int> 的所有成员函数
template class Stack<double>;        // 强制编译器生成 Stack<double> 的所有成员函数

// ---- stack.h ----
template <typename T>
class Stack { /* ... 完整定义 ... */ };
 
// 告诉编译器：不要在本翻译单元中实例化 Stack<int>，
// 它会在别处被显式实例化
extern template class Stack<int>;
 
// ---- stack.cpp ----
#include "stack.h"
// 在此处显式实例化，整个项目中只编译这一次
template class Stack<int>;

template <typename T>
class Stack {
private:
    std::vector<T> elems_;  // 底层存储容器
 
public:
    void push(const T& elem);   // 仅声明
    void pop();                  // 仅声明
    const T& top() const;       // 仅声明
    bool empty() const;         // 仅声明
};
 
// 类外定义 push：必须重复 template<typename T>
// 作用域写成 Stack<T>::，而不是 Stack::
template <typename T>
void Stack<T>::push(const T& elem) {
    elems_.push_back(elem);     // 将元素追加到 vector 尾部
}
 
// 类外定义 pop
template <typename T>
void Stack<T>::pop() {
    if (elems_.empty()) {       // 检查栈是否为空
        throw std::out_of_range("Stack::pop(): empty stack");
    }
    elems_.pop_back();          // 移除栈顶元素
}
 
// 类外定义 top
template <typename T>
const T& Stack<T>::top() const {
    if (elems_.empty()) {       // 检查栈是否为空
        throw std::out_of_range("Stack::top(): empty stack");
    }
    return elems_.back();       // 返回栈顶元素的引用
}
 
// 类外定义 empty
template <typename T>
bool Stack<T>::empty() const {
    return elems_.empty();      // 委托给 vector::empty()
}

// T: 元素类型，默认为 int
// Container: 底层容器类型，默认为 std::vector<T>
// 这种"以一个模板参数作为另一个参数的默认值"的用法非常常见
template <typename T = int, typename Container = std::vector<T>>
class Stack {
private:
    Container elems_;             // 使用 Container 而非硬编码的 vector<T>
 
public:
    void push(const T& elem) {
        elems_.push_back(elem);   // 要求 Container 支持 push_back
    }
 
    void pop() {
        if (elems_.empty()) {     // 要求 Container 支持 empty()
            throw std::out_of_range("Stack::pop(): empty stack");
        }
        elems_.pop_back();        // 要求 Container 支持 pop_back()
    }
 
    const T& top() const {
        if (elems_.empty()) {
            throw std::out_of_range("Stack::top(): empty stack");
        }
        return elems_.back();     // 要求 Container 支持 back()
    }
 
    bool empty() const {
        return elems_.empty();
    }
};

int main() {
    // 全部使用默认参数：T=int, Container=vector<int>
    Stack<> s1;
    s1.push(10);                          // 存储 int 元素
 
    // 指定 T=double，Container 使用默认的 vector<double>
    Stack<double> s2;
    s2.push(3.14);                        // 存储 double 元素
 
    // 指定 T=int，Container=std::deque<int>
    // 用双端队列替代 vector 作为底层存储
    Stack<int, std::deque<int>> s3;
    s3.push(99);                          // 底层使用 deque 存储
 
    return 0;
}

#include <iostream>
#include <stdexcept>
#include <array>
 
// T: 元素类型
// MaxSize: 栈的最大容量，是一个编译期常量
// 注意 MaxSize 的类型是 std::size_t（无符号整型）
template <typename T, std::size_t MaxSize>
class FixedStack {
private:
    std::array<T, MaxSize> elems_;  // 用 std::array 在栈上分配固定大小的存储
    std::size_t count_ = 0;         // 当前元素个数，初始化为 0
 
public:
    // 压入元素
    void push(const T& elem) {
        if (count_ >= MaxSize) {    // 检查是否已满
            throw std::overflow_error("FixedStack::push(): stack is full");
        }
        elems_[count_] = elem;      // 在当前位置存储元素
        ++count_;                    // 元素计数 +1
    }
 
    // 弹出元素
    void pop() {
        if (count_ == 0) {          // 检查是否为空
            throw std::underflow_error("FixedStack::pop(): stack is empty");
        }
        --count_;                    // 元素计数 -1（无需真正擦除数据）
    }
 
    // 获取栈顶元素
    const T& top() const {
        if (count_ == 0) {
            throw std::underflow_error("FixedStack::top(): stack is empty");
        }
        return elems_[count_ - 1];  // 返回最顶部的元素
    }
 
    // 返回最大容量（编译期常量）
    constexpr std::size_t capacity() const {
        return MaxSize;              // MaxSize 在编译期就已确定
    }
 
    // 返回当前元素个数
    std::size_t size() const {
        return count_;
    }
};

int main() {
    FixedStack<int, 5> s1;         // 最多存 5 个 int
    FixedStack<double, 100> s2;    // 最多存 100 个 double
 
    s1.push(10);                   // 压入第一个元素
    s1.push(20);                   // 压入第二个元素
    std::cout << s1.top() << std::endl;     // 输出 20
    std::cout << s1.capacity() << std::endl; // 输出 5（编译期常量）
 
    // FixedStack<int, 5> 和 FixedStack<int, 10> 是完全不同的类型！
    // FixedStack<int, 5> a;
    // FixedStack<int, 10> b;
    // a = b;  // ❌ 编译错误！类型不匹配
 
    return 0;
}

template <typename T>
class Box {
private:
    T value_;                               // 存储的值
 
public:
    explicit Box(const T& v) : value_(v) {} // 构造函数
 
    // 在类体内定义友元函数
    // 这个 operator<< 不是模板函数，而是为每个 Box<T> 实例化生成的普通函数
    friend std::ostream& operator<<(std::ostream& os, const Box& b) {
        os << "[Box: " << b.value_ << "]";  // 直接访问 private 成员 value_
        return os;                           // 返回流以支持链式输出
    }
};

// 第一步：前置声明类模板
template <typename T>
class Box;
 
// 第二步：前置声明函数模板
template <typename T>
std::ostream& operator<<(std::ostream& os, const Box<T>& b);
 
// 第三步：定义类模板
template <typename T>
class Box {
private:
    T value_;
 
public:
    explicit Box(const T& v) : value_(v) {}
 
    // 声明友元时，必须在函数名后加 <T> 或 <>，
    // 表明这是一个函数模板的特定实例化
    friend std::ostream& operator<< <T>(std::ostream& os, const Box<T>& b);
};
 
// 第四步：类外定义函数模板
template <typename T>
std::ostream& operator<<(std::ostream& os, const Box<T>& b) {
    os << "[Box: " << b.value_ << "]";  // 访问 private 成员
    return os;
}

template <typename T>
class Counter {
public:
    static int count_;                  // 静态成员变量声明
 
    Counter() { ++count_; }             // 构造时 +1
    ~Counter() { --count_; }            // 析构时 -1
};
 
// 类外定义静态成员变量（每个实例化类型各有一份）
// 必须加 template<typename T> 前缀
template <typename T>
int Counter<T>::count_ = 0;             // 初始化为 0

int main() {
    Counter<int> a, b, c;               // 创建 3 个 Counter<int> 对象
    Counter<double> x;                  // 创建 1 个 Counter<double> 对象
 
    // Counter<int>::count_ == 3   (a, b, c 三个对象)
    // Counter<double>::count_ == 1 (x 一个对象)
    std::cout << Counter<int>::count_ << std::endl;     // 输出 3
    std::cout << Counter<double>::count_ << std::endl;  // 输出 1
 
    // Counter<int> 和 Counter<double> 的 count_ 是完全独立的！
    return 0;
}

// ===== 内存布局示意 =====
//
//  Counter<int> 的静态区域          Counter<double> 的静态区域
//  ┌─────────────────────┐         ┌─────────────────────┐
//  │  count_ = 3         │         │  count_ = 1         │
//  └─────────────────────┘         └─────────────────────┘
//         ▲  ▲  ▲                          ▲
//         │  │  │                          │
//     ┌───┘  │  └───┐                     │
//     a      b      c                     x
//   (int)  (int)  (int)               (double)
//
//  每个实例化类型拥有独立的 static 变量副本

// 基类模板：提供通用的数组功能
template <typename T>
class Array {
protected:
    T* data_;                   // 指向动态分配内存的指针
    std::size_t size_;          // 数组大小
 
public:
    // 构造函数：分配 n 个 T 类型的空间
    explicit Array(std::size_t n) : data_(new T[n]{}), size_(n) {}
 
    // 析构函数：释放内存
    virtual ~Array() { delete[] data_; }
 
    // 下标访问运算符
    T& operator[](std::size_t i) { return data_[i]; }
 
    // 获取大小
    std::size_t size() const { return size_; }
};
 
// 派生类模板：在 Array 基础上添加排序功能
template <typename T>
class SortableArray : public Array<T> {   // 继承自 Array<T>
public:
    // 构造函数：转发参数给基类
    explicit SortableArray(std::size_t n) : Array<T>(n) {}
 
    // 冒泡排序（要求 T 支持 operator<）
    void sort() {
        for (std::size_t i = 0; i < this->size_; ++i) {        // 外层循环
            for (std::size_t j = i + 1; j < this->size_; ++j) { // 内层循环
                if (this->data_[j] < this->data_[i]) {          // 比较元素
                    std::swap(this->data_[i], this->data_[j]);  // 交换
                }
            }
        }
    }
};

// 用具体类型实例化基类模板，然后继承
class IntStack : public Stack<int> {   // 继承自 Stack<int>（一个具体的类）
public:
    // 添加额外功能：打印所有元素
    void printAll() const {
        // IntStack 继承了 Stack<int> 的所有 public 成员
        std::cout << "IntStack contents" << std::endl;
    }
};

#include <vector>
#include <mutex>
 
// C++17 之前：必须显式指定类型
std::pair<int, double> p1(42, 3.14);       // 冗长
std::vector<int> v1 = {1, 2, 3};           // 必须写 <int>
 
// C++17 CTAD：编译器自动推导
std::pair p2(42, 3.14);                    // 推导为 pair<int, double>
std::vector v2 = {1, 2, 3};               // 推导为 vector<int>
std::tuple t(1, 2.5, "hello");            // 推导为 tuple<int, double, const char*>

template <typename T>
class Wrapper {
public:
    T value_;
 
    // 编译器会根据这个构造函数的参数类型推导 T
    Wrapper(T v) : value_(v) {}
};
 
int main() {
    Wrapper w1(42);             // T 被推导为 int
    Wrapper w2(3.14);           // T 被推导为 double
    Wrapper w3("hello");        // T 被推导为 const char*（注意不是 string！）
    return 0;
}

// 推导指引：当传入 const char* 时，将 T 推导为 std::string
// 格式：模板名(参数) -> 模板名<期望类型>
Wrapper(const char*) -> Wrapper<std::string>;
 
int main() {
    Wrapper w("hello");         // 现在 T 被推导为 std::string 而非 const char*
    // w.value_ 的类型是 std::string
    return 0;
}

#include <vector>
#include <map>
#include <string>
 
// 传统 typedef（无法直接用于模板）
typedef std::vector<int> IntVec;            // OK，但只能为具体类型起别名
 
// C++11 using 别名声明（更强大，支持模板）
using IntVec2 = std::vector<int>;           // 等价于上面的 typedef
 
// ✨ 模板别名：typedef 做不到的事
template <typename T>
using Vec = std::vector<T>;                 // Vec<T> 是 vector<T> 的别名
 
template <typename V>
using StringMap = std::map<std::string, V>; // StringMap<V> 是 map<string, V> 的别名
 
int main() {
    Vec<double> v = {1.1, 2.2, 3.3};       // 等价于 vector<double>
    StringMap<int> m;                        // 等价于 map<string, int>
    m["age"] = 25;                           // 使用方式完全相同
    m["score"] = 100;
 
    return 0;
}

#include <iostream>
#include <algorithm>    // std::copy
#include <stdexcept>    // std::out_of_range
#include <initializer_list> // std::initializer_list
 
template <typename T>
class SimpleVector {
private:
    T* data_;               // 指向堆上动态分配的数组
    std::size_t size_;      // 当前存储的元素个数
    std::size_t capacity_;  // 当前分配的总容量
 
    // 私有辅助函数：扩容
    void grow() {
        // 新容量 = 旧容量的 2 倍（若为 0 则初始化为 1）
        std::size_t newCap = (capacity_ == 0) ? 1 : capacity_ * 2;
 
        T* newData = new T[newCap];               // 分配新的更大的内存块
        std::copy(data_, data_ + size_, newData);  // 将旧数据拷贝到新内存
        delete[] data_;                            // 释放旧内存
        data_ = newData;                           // 指向新内存
        capacity_ = newCap;                        // 更新容量
    }
 
public:
    // 默认构造函数
    SimpleVector()
        : data_(nullptr)     // 初始无内存分配
        , size_(0)           // 元素个数为 0
        , capacity_(0)       // 容量为 0
    {}
 
    // initializer_list 构造函数：支持 SimpleVector<int> v = {1, 2, 3};
    SimpleVector(std::initializer_list<T> init)
        : data_(new T[init.size()])      // 分配刚好够用的内存
        , size_(init.size())             // 设置元素个数
        , capacity_(init.size())         // 初始容量等于元素个数
    {
        std::copy(init.begin(), init.end(), data_);  // 将初始化列表中的元素拷贝过来
    }
 
    // 拷贝构造函数（深拷贝）
    SimpleVector(const SimpleVector& other)
        : data_(new T[other.capacity_])  // 分配与源对象相同容量的内存
        , size_(other.size_)             // 拷贝元素个数
        , capacity_(other.capacity_)     // 拷贝容量
    {
        std::copy(other.data_, other.data_ + other.size_, data_);  // 深拷贝数据
    }
 
    // 拷贝赋值运算符（copy-and-swap idiom）
    SimpleVector& operator=(SimpleVector other) {  // 注意：按值传递，触发拷贝构造
        std::swap(data_, other.data_);             // 交换数据指针
        std::swap(size_, other.size_);             // 交换大小
        std::swap(capacity_, other.capacity_);     // 交换容量
        return *this;                              // other 析构时自动释放旧数据
    }
 
    // 移动构造函数
    SimpleVector(SimpleVector&& other) noexcept
        : data_(other.data_)             // "窃取"源对象的指针
        , size_(other.size_)             // 接管大小
        , capacity_(other.capacity_)     // 接管容量
    {
        other.data_ = nullptr;           // 源对象指针置空，防止 double free
        other.size_ = 0;                 // 源对象大小归零
        other.capacity_ = 0;             // 源对象容量归零
    }
 
    // 析构函数
    ~SimpleVector() {
        delete[] data_;                  // 释放动态分配的内存
    }
 
    // 尾部追加元素
    void push_back(const T& value) {
        if (size_ >= capacity_) {        // 空间不足时扩容
            grow();
        }
        data_[size_] = value;            // 在末尾位置放置新元素
        ++size_;                         // 元素计数 +1
    }
 
    // 下标访问（带边界检查）
    T& operator[](std::size_t index) {
        if (index >= size_) {            // 越界检查
            throw std::out_of_range("SimpleVector: index out of range");
        }
        return data_[index];             // 返回对应元素的引用
    }
 
    // const 版本的下标访问
    const T& operator[](std::size_t index) const {
        if (index >= size_) {
            throw std::out_of_range("SimpleVector: index out of range");
        }
        return data_[index];
    }
 
    // 获取元素个数
    std::size_t size() const { return size_; }
 
    // 获取容量
    std::size_t capacity() const { return capacity_; }
 
    // 判空
    bool empty() const { return size_ == 0; }
 
    // 友元：重载输出运算符，直接在类体内定义
    friend std::ostream& operator<<(std::ostream& os, const SimpleVector& vec) {
        os << "[";                             // 左括号
        for (std::size_t i = 0; i < vec.size_; ++i) {
            if (i > 0) os << ", ";             // 元素间用逗号分隔
            os << vec.data_[i];                // 输出每个元素
        }
        os << "]";                             // 右括号
        return os;
    }
};

int main() {
    // 使用 initializer_list 构造
    SimpleVector<int> v1 = {10, 20, 30};       // [10, 20, 30]
    std::cout << "v1 = " << v1 << std::endl;   // 输出 [10, 20, 30]
 
    // push_back 触发扩容
    v1.push_back(40);                          // [10, 20, 30, 40]，容量从 3 扩到 6
    v1.push_back(50);                          // [10, 20, 30, 40, 50]
    std::cout << "v1 = " << v1 << std::endl;
    std::cout << "size=" << v1.size()
              << ", capacity=" << v1.capacity() << std::endl;
 
    // 拷贝构造（深拷贝）
    SimpleVector<int> v2 = v1;                 // v2 是 v1 的独立副本
    v2.push_back(60);                          // 修改 v2 不影响 v1
    std::cout << "v1 = " << v1 << std::endl;   // v1 不受影响
    std::cout << "v2 = " << v2 << std::endl;
 
    // 移动构造
    SimpleVector<int> v3 = std::move(v1);      // v1 的资源被转移给 v3
    std::cout << "v3 = " << v3 << std::endl;   // v3 拥有原 v1 的数据
    std::cout << "v1 is empty: " << v1.empty() << std::endl;  // v1 现在为空
 
    // 存储 string 类型
    SimpleVector<std::string> sv = {"hello", "world", "cpp"};
    std::cout << "sv = " << sv << std::endl;   // [hello, world, cpp]
 
    return 0;
}

template <typename T>
void printSize(const T& container) {
    // typename 告诉编译器 T::size_type 是一个类型，而不是静态成员变量
    typename T::size_type sz = container.size();   // 必须加 typename
    std::cout << sz << std::endl;
}

#include <type_traits>    // 类型萃取工具
 
template <typename T>
class NumericStack {
    // 在编译期就检查 T 是否为算术类型
    // 若不是，则编译器直接给出清晰的错误消息
    static_assert(std::is_arithmetic<T>::value,
                  "NumericStack requires an arithmetic type!");
 
private:
    std::vector<T> elems_;
 
public:
    void push(T val) { elems_.push_back(val); }
    // ...
};
 
// NumericStack<int> ok;          // ✅ int 是算术类型
// NumericStack<std::string> bad; // ❌ 编译错误，给出清晰提示

template <typename T>
class Foo {
public:
    static int count;
    Foo() { ++count; }
};
 
template <typename T>
int Foo<T>::count = 0;
 
int main() {
    Foo<int> a, b;
    Foo<double> c;
    Foo<int> d;
    std::cout << Foo<int>::count << " " << Foo<double>::count << std::endl;
    return 0;
}

#include <iostream>
#include <cstring>  // std::strcmp
 
// ============ 主模板 (Primary Template) ============
template <typename T>
bool isEqual(const T& a, const T& b) {
    // 对于大多数类型，直接使用 operator== 比较
    return a == b;
}
 
// ============ 全特化：T = const char* ============
// template<> 尖括号留空，表示所有模板参数都已确定
// 函数名后 <const char*> 指定特化的目标类型
template <>
bool isEqual<const char*>(const char* const& a, const char* const& b) {
    // 对于 C 风格字符串，比较内容而非指针地址
    // std::strcmp 返回 0 表示两个字符串内容相同
    return std::strcmp(a, b) == 0;
}
 
int main() {
    // 调用主模板：T = int，使用 operator== 比较
    std::cout << std::boolalpha;
    std::cout << isEqual(1, 1) << "\n";           // true
 
    // 调用全特化版本：T = const char*
    const char* s1 = "hello";
    const char* s2 = "hello";
    // 虽然 s1 和 s2 可能指向不同地址，但内容相同 → true
    std::cout << isEqual(s1, s2) << "\n";          // true
 
    return 0;
}

#include <iostream>
#include <cstring>
 
// ============ 主模板 ============
template <typename T>
class Storage {
    T value_;                         // 存储任意类型的值
public:
    Storage(const T& val) : value_(val) {}  // 构造函数，拷贝初始化
    T getValue() const { return value_; }   // 返回存储的值
    void print() const {                     // 打印值
        std::cout << "Storage<T>: " << value_ << "\n";
    }
};
 
// ============ 全特化：T = const char* ============
template <>
class Storage<const char*> {
    char* value_;                     // 不再存储指针，而是深拷贝字符串
public:
    Storage(const char* val) {
        // 计算字符串长度（含 '\0'）
        size_t len = std::strlen(val) + 1;
        // 在堆上分配内存
        value_ = new char[len];
        // 将源字符串内容拷贝到新分配的内存中
        std::strcpy(value_, val);
    }
 
    ~Storage() {
        // 释放堆上分配的内存，防止内存泄漏
        delete[] value_;
    }
 
    // 返回内部字符串指针（只读）
    const char* getValue() const { return value_; }
 
    void print() const {
        // 使用特化版本特有的输出格式
        std::cout << "Storage<const char*>: \"" << value_ << "\"\n";
    }
};
 
int main() {
    Storage<int> si(42);              // 实例化主模板，T = int
    si.print();                       // 输出: Storage<T>: 42
 
    Storage<const char*> ss("hello"); // 实例化全特化版本
    ss.print();                       // 输出: Storage<const char*>: "hello"
 
    return 0;
}

#include <iostream>
 
// ============ 主模板：两个类型参数 ============
template <typename T, typename U>
class Pair {
public:
    void describe() const {
        // 通用版本，两个参数都未确定
        std::cout << "Pair<T, U> - 完全泛型版本\n";
    }
};
 
// ============ 偏特化：固定第二个参数为 int ============
// template<typename T> 表示仍有一个参数未确定
// Pair<T, int> 表示第二个参数被固定为 int
template <typename T>
class Pair<T, int> {
public:
    void describe() const {
        // 当第二个类型是 int 时，使用此版本
        std::cout << "Pair<T, int> - 第二参数固定为 int 的偏特化\n";
    }
};
 
// ============ 偏特化：两个参数类型相同 ============
template <typename T>
class Pair<T, T> {
public:
    void describe() const {
        // 当两个类型完全相同时，使用此版本
        std::cout << "Pair<T, T> - 两参数同类型的偏特化\n";
    }
};
 
int main() {
    Pair<double, char>  p1;   // 匹配主模板
    Pair<double, int>   p2;   // 匹配偏特化 Pair<T, int>，T=double
    Pair<float, float>  p3;   // 匹配偏特化 Pair<T, T>，T=float
    // Pair<int, int>   p4;   // ⚠ 歧义！同时匹配 <T,int> 和 <T,T>
                               // 编译器无法决定，会报 ambiguous 错误
 
    p1.describe();  // Pair<T, U> - 完全泛型版本
    p2.describe();  // Pair<T, int> - 第二参数固定为 int 的偏特化
    p3.describe();  // Pair<T, T> - 两参数同类型的偏特化
 
    return 0;
}

#include <iostream>
 
// ============ 主模板 ============
template <typename T>
class TypeTraits {
public:
    static void info() {
        // 默认：非指针类型
        std::cout << "TypeTraits<T>: 普通值类型 (Value Type)\n";
    }
};
 
// ============ 偏特化：匹配所有指针类型 T* ============
// 这里 T 仍然是泛型参数，但整体模式被约束为"T 的指针"
template <typename T>
class TypeTraits<T*> {
public:
    // 使用 typedef 暴露"去除指针后的底层类型"
    using baseType = T;
 
    static void info() {
        std::cout << "TypeTraits<T*>: 指针类型 (Pointer Type)\n";
    }
};
 
// ============ 偏特化：匹配所有 const 指针类型 const T* ============
template <typename T>
class TypeTraits<const T*> {
public:
    using baseType = T;
 
    static void info() {
        std::cout << "TypeTraits<const T*>: 常量指针类型\n";
    }
};
 
int main() {
    TypeTraits<int>::info();          // 普通值类型
    TypeTraits<int*>::info();         // 指针类型
    TypeTraits<const int*>::info();   // 常量指针类型
    TypeTraits<double**>::info();     // 指针类型 (T = double*)
 
    return 0;
}

#include <iostream>
 
// ============ 主模板 ============
template <typename T>
class Inspector {
public:
    static void analyze() {
        std::cout << "Inspector<T>: 标量或普通类型\n";
    }
};
 
// ============ 偏特化：固定大小数组 T[N] ============
// 这里有两个模板参数：类型 T 和非类型参数 N
template <typename T, size_t N>
class Inspector<T[N]> {
public:
    static void analyze() {
        // 能够在编译期获取数组元素类型和长度
        std::cout << "Inspector<T[N]>: 数组类型, "
                  << "元素数量 = " << N << "\n";
    }
};
 
// ============ 偏特化：引用类型 T& ============
template <typename T>
class Inspector<T&> {
public:
    static void analyze() {
        std::cout << "Inspector<T&>: 左值引用类型\n";
    }
};
 
int main() {
    Inspector<int>::analyze();           // 标量或普通类型
    Inspector<int[5]>::analyze();        // 数组类型, 元素数量 = 5
    Inspector<double&>::analyze();       // 左值引用类型
    Inspector<char[128]>::analyze();     // 数组类型, 元素数量 = 128
 
    return 0;
}

#include <iostream>
 
// 主模板
template <typename T>
class Match {
public:
    static void who() { std::cout << "主模板\n"; }
};
 
// 偏特化：指针类型
template <typename T>
class Match<T*> {
public:
    static void who() { std::cout << "偏特化 T*\n"; }
};
 
// 全特化：int*
template <>
class Match<int*> {
public:
    static void who() { std::cout << "全特化 int*\n"; }
};
 
int main() {
    Match<double>::who();   // → 主模板 (无特化匹配)
    Match<double*>::who();  // → 偏特化 T* (T=double)
    Match<int*>::who();     // → 全特化 int* (精确匹配，优先级最高)
 
    return 0;
}

#include <iostream>
 
// ============ 主模板 A ============
template <typename T>
void process(T val) {
    std::cout << "[主模板 A] process(T)\n";
}
 
// ============ 对主模板 A 的全特化：T = int* ============
template <>
void process<int*>(int* val) {
    std::cout << "[全特化] process(int*)\n";
}
 
// ============ 主模板 B（重载）============
template <typename T>
void process(T* val) {
    std::cout << "[主模板 B] process(T*)\n";
}
 
int main() {
    int x = 42;
    int* p = &x;
    process(p);   // 你以为会调用全特化 int* 版本？
    return 0;
}

#include <iostream>
 
// 主模板
template <typename T>
void process(T val) {
    std::cout << "[模板] process(T)\n";
}
 
// 普通函数重载（非模板）
// 普通函数在重载决议中优先级高于模板
void process(int* val) {
    std::cout << "[普通重载] process(int*)\n";
}
 
int main() {
    int x = 42;
    int* p = &x;
    process(p);   // → [普通重载] process(int*)  ✅ 符合预期
    return 0;
}

#include <iostream>
 
// 主模板：默认情况，T 不是指针
template <typename T>
struct is_pointer {
    // 编译期常量：false
    static constexpr bool value = false;
};
 
// 偏特化：当 T 的形式是 U* 时匹配
template <typename U>
struct is_pointer<U*> {
    // 编译期常量：true
    static constexpr bool value = true;
};
 
// 进一步：处理 const 指针
template <typename U>
struct is_pointer<U* const> {
    static constexpr bool value = true;
};
 
int main() {
    std::cout << std::boolalpha;
    std::cout << is_pointer<int>::value      << "\n";  // false
    std::cout << is_pointer<int*>::value     << "\n";  // true
    std::cout << is_pointer<double**>::value << "\n";  // true (U = double*)
    std::cout << is_pointer<char* const>::value << "\n"; // true
 
    return 0;
}

#include <iostream>
 
// 主模板：递归定义 N! = N * (N-1)!
template <int N>
struct Factorial {
    // 编译期递归：值 = N 乘以 Factorial<N-1> 的值
    static constexpr long long value = N * Factorial<N - 1>::value;
};
 
// 全特化：N = 0 时，0! = 1，递归终止
template <>
struct Factorial<0> {
    static constexpr long long value = 1;
};
 
int main() {
    // 所有计算在编译期完成，运行时只是读取常量
    std::cout << "5!  = " << Factorial<5>::value  << "\n"; // 120
    std::cout << "10! = " << Factorial<10>::value << "\n"; // 3628800
    std::cout << "20! = " << Factorial<20>::value << "\n"; // 2432902008176640000
 
    return 0;
}

#include <iostream>
 
template <typename T, typename U>
struct X {
    static void f() { std::cout << "1"; }
};
 
template <typename T>
struct X<T, T> {
    static void f() { std::cout << "2"; }
};
 
template <typename T>
struct X<T, int> {
    static void f() { std::cout << "3"; }
};
 
template <>
struct X<int, int> {
    static void f() { std::cout << "4"; }
};
 
int main() {
    X<double, char>::f();
    X<double, double>::f();
    X<double, int>::f();
    X<int, int>::f();
}