C++ 模板深入进阶：原理与实战技巧

此外，现代 C++ 中也可以使用 auto 来简化迭代器声明，因为 auto 推导的结果必然是类型，不会引起歧义：

template <typename Container>
void Print(const Container& con) {
    auto it = con.begin();
    while (it != con.end()) {
        cout << *it << " ";
        ++it;
    }
}

但需注意，auto 不能用于模板参数列表中，因此在某些特定场景下仍需 typename。

非类型模板参数

模板参数分为类型形参和非类型形参。非类型形参允许使用常量作为模板参数，在编译期就能确认结果。

1. 用法示例

传统方式定义固定大小的栈往往受限于宏或默认值，不够灵活。利用非类型模板参数可以定义不同大小的静态栈：

// 非类型模板参数必须是整形家族 (size_t, char, int 等)
template <class T, size_t N>
class Stack {
public:
    void func() {
        // N 是常量，不可修改
    }
private:
    T _array[N];
    int _top;
};

int main() {
    Stack<int, 10> st1;
    Stack<int, 20> st2;
    return 0;
}

注意事项：

• 浮点数、类对象及字符串不允许作为非类型模板参数。
• 非类型模板参数必须在编译期确定。
• 一旦定义，在模板内部不可修改该参数。

2. std::array 的应用

std::array 是 C++11 引入的静态数组，底层使用了非类型模板参数。虽然功能上可以用 vector 替代，但 std::array 提供了更严格的越界检查（配合调试）和标准库的重载支持。

模板的特化

当通用模板无法满足特定类型的处理需求时，就需要进行特化。

1. 函数模板特化 vs 重载

对于函数模板，如果存在特殊类型需要单独处理，通常优先考虑函数重载而非特化，除非逻辑确实高度耦合。

例如比较值的函数：

// 通用版本：按值比较
template <class T>
bool Less(T left, T right) {
    return left < right;
}

// 针对指针的特化（推荐直接写重载）
template <class T>
bool Less(T* left, T* right) {
    return *left < *right;
}

直接编写重载版本通常比特化更清晰，且能有效避免代码膨胀。

2. 类模板特化

类模板特化分为全特化和偏特化。

全特化： 指定所有模板参数。

template <class T1, class T2>
class Data { /* ... */ };

// 全特化
template <>
class Data<int, double> {
    // 针对 int 和 double 的特殊实现
};

偏特化： 对部分参数进行限制或特化。

// 偏特化：第二个参数固定为 double
template <class T>
class Data<T, double> {
    // ... 
};

// 偏特化：指针类型
template <class T1, class T2>
class Data<T1*, T2*> {
    // ... 
};

实际应用案例： 在使用 sort 排序 Date* 指针时，默认会按地址大小排序。若希望按日期值排序，需要对比较器类进行特化：

template <class T>
class Less {
public:
    bool operator()(const T& x, const T& y) const {
        return x < y;
    }
};

// 特化指针版本
template <>
class Less<Date*> {
public:
    bool operator()(Date* x, Date* y) const {
        return *x < *y; // 解引用后比较
    }
};

模板的分离编译

C/C++ 程序通常经历预处理、编译、汇编、链接四个过程。模板的分离编译常遇到链接错误。

1. 问题根源

普通函数在 .cpp 文件中定义后，编译器能生成符号表地址供链接使用。但模板函数在 .cpp 中定义时，由于模板参数未实例化，编译器无法生成具体的函数地址。因此，即使 .cpp 中有定义，链接器也找不到符号，导致'无法解析的外部符号'错误。

2. 解决方案

方案一：显式实例化 在 .cpp 中强制实例化特定类型：

template class Stack<int>;
template class Stack<double>;

缺点是需要手动维护每种类型，不实用。

方案二：头文件包含实现（推荐） 将模板类的声明和定义都放在同一个头文件（如 .hpp）中。这样每个使用该模板的源文件在预处理时都会包含完整的定义，从而在各自编译单元中完成实例化。

// Stack.hpp
#pragma once
#include <iostream>
#include <deque>

namespace m_stack {
template <class T, class Container = std::deque<T>>
class Stack {
public:
    void push(const T& ele);
    void pop();
    // ... 其他成员函数定义直接写在头文件中
};

// 成员函数实现
template <class T, class Container>
void Stack<T, Container>::push(const T& ele) {
    _con.push_back(ele);
}
}

这种方式避免了链接错误，也是 STL 的标准做法。

总结

优点

• 代码复用：一套逻辑适用于多种类型。
• 类型安全：编译期检查，无运行时类型错误。
• 性能优化：生成的代码接近手写专用代码，无虚函数开销。

缺点

• 编译时间：大量实例化会显著增加编译时间。
• 代码膨胀：多类型实例化可能导致二进制体积增大。
• 调试困难：模板错误信息冗长晦涩。

在实际开发中，建议在通用库和高性能算法场景下合理使用模板，同时注意控制实例化范围以平衡效率与灵活性。