C++ 模板：函数模板与类模板

C++ 模板是泛型编程的核心机制，它允许你编写与类型无关的代码。模板就像一个蓝图，编译器会根据你提供的具体类型生成对应的代码。这种机制能够大幅减少重复代码，同时保持类型安全。

一、模板的本质：编译期的代码生成

模板并不是运行时的动态机制，而是在编译期工作的代码生成器。当你写下一个模板时，编译器会在编译过程中根据实际使用的类型，创建出多个版本的函数或类。

理解这一点至关重要：模板本身不会生成任何可执行代码，只有当你实际调用模板函数或创建模板类的对象时，编译器才会实例化出具体的代码。例如，如果你只定义了一个 vector<T> 模板但从未使用它，最终的可执行文件中就不会包含 vector 的任何代码。

二、函数模板：编写通用函数

函数模板允许你定义一类相似的函数，这些函数执行相同的逻辑但操作在不同类型的数据上。

2.1 基本语法

定义函数模板需要使用 template 关键字，后跟用尖括号包裹的模板参数列表：

template<typename T>
T add(T a, T b) {
    return a + b;
}

typename 和 class 在模板参数中可以互换使用，两者在语义上没有区别。使用 typename 是现代 C++ 的推荐写法，因为它更明确地表达了你是在引用一个类型而非一个类。

调用函数模板时，编译器会自动推断模板参数，也可以显式指定：

int main() {
    // 类型推断
    int sum1 = add(3, 5);           // T 被推断为 int
    double sum2 = add(2.5, 3.7);    // T 被推断为 double

    // 显式指定模板参数
    int sum3 = add<int>(10, 20);

    return 0;
}

2.2 多参数模板

函数模板可以包含多个模板参数，甚至可以混用类型参数和非类型参数：

// 两个类型参数
template<typename T1, typename T2>
std::pair<T1, T2> make_pair(T1 a, T2 b) {
    return std::pair<T1, T2>(a, b);
}

// 类型参数 + 非类型参数
template<typename T, size_t N>
class Array {
    T data[N];
};

// 使用示例
Array<int, 100> arr;  // 创建一个能存储 100 个 int 的数组

2.3 模板特化

当你需要对特定类型进行特殊处理时，可以使用模板特化。完全特化为特定类型提供完全不同的实现：

template<typename T>
T multiply(T a, T b) {
    return a * b;
}

// 针对 const char* 的完全特化
template<>
const char* multiply<const char*>(const char* a, const char* b) {
    // 字符串拼接逻辑
    return strcat(strdup(a), b);
}

部分特化（仅适用于类模板）允许你只为满足特定条件的类型提供特殊实现：

template<typename T>
class Printer {
public:
    void print(T value) {
        std::cout << value << std::endl;
    }
};

// 当 T 是指针类型时的部分特化
template<typename T>
class Printer<T*> {
public:
    void print(T* value) {
        if (value) {
            std::cout << *value << std::endl;
        }
    }
};

三、类模板：构建通用类型

类模板是创建通用类的蓝图，标准库中的 vector、stack、queue 等容器都是类模板的经典应用。

3.1 基本定义

类模板的定义语法与函数模板类似，但类模板的所有成员函数如果在类外定义，都需要重复模板声明：

template<typename T>
class Box {
private:
    T content;
public:
    Box(T item) : content(item) {}

    T getContent() const {
        return content;
    }

    void setContent(T item) {
        content = item;
    }
};

// 类外定义成员函数时需要重复模板声明
template<typename T>
void Box<T>::setContent(T item) {
    this->content = item;
}

3.2 成员函数模板

类的成员函数本身也可以是模板，这种嵌套结构提供了极大的灵活性：

template<typename T>
class Calculator {
public:
    // 成员函数模板
    template<typename U>
    T convert(U value) {
        return static_cast<T>(value);
    }

    // 普通成员函数
    T add(T a, T b) {
        return a + b;
    }
};

int main() {
    Calculator<double> calc;
    int i = 42;
    double d = calc.convert(i);  // 将 int 转换为 double
}

3.3 默认模板参数

C++11 起，类模板支持默认模板参数，这使得模板的使用更加灵活：

template<typename T, typename Allocator = std::allocator<T>>
class Vector {
    // 使用默认分配器
};

template<typename T = int, size_t MaxSize = 100>
class Stack {
private:
    T elements[MaxSize];
    size_t top;
public:
    Stack() : top(0) {}

    void push(T item) {
        elements[top++] = item;
    }

    T pop() {
        return elements[--top];
    }
};

// 使用默认参数
Stack<> intStack;           // Stack<int, 100>
Stack<double, 50> dStack;   // Stack<double, 50>

3.4 模板类继承

模板类可以继承自普通类、普通模板类或其他模板类，形成复杂的继承体系：

// 普通基类
class Base {
public:
    virtual ~Base() = default;
    virtual void describe() = 0;
};

// 模板派生类
template<typename T>
class Derived : public Base {
private:
    T value;
public:
    Derived(T v) : value(v) {}

    void describe() override {
        std::cout << value << std::endl;
    }
};

// 模板基类
template<typename T>
class Container {
protected:
    std::vector<T> items;
public:
    void add(T item) {
        items.push_back(item);
    }

    size_t size() const {
        return items.size();
    }
};

// 模板基类的模板派生类
template<typename T>
class Stack : public Container<T> {
public:
    void push(T item) {
        Container<T>::add(item);
    }
};

四、模板实战的常见模式

4.1 类型特征与 SFINAE

SFINAE（Substitution Failure Is Not An Error）是模板元编程的核心技术，它允许你根据类型特性选择不同的模板重载：

#include <type_traits>

// 检测类型是否支持加法的辅助模板
template<typename T>
class supports_addition {
private:
    template<typename U>
    static auto test(int) -> decltype(std::declval<U>() + std::declval<U>(), std::true_type());

    template<typename U>
    static std::false_type test(...);

public:
    static constexpr bool value = decltype test<T>(0)::value;
};

// 使用示例
template<typename T>
typename std::enable_if<supports_addition<T>::value, T>::type
safe_add(T a, T b) {
    return a + b;
}

4.2 编译期条件分支

if constexpr（C++17）是处理编译期条件逻辑的强大工具，它允许你在模板代码中根据类型条件选择执行不同的分支：

template<typename T>
void process(T value) {
    if constexpr (std::is_integral_v<T>) {
        // 整数类型的处理逻辑
        std::cout << "Integer: " << value << std::endl;
    } else if constexpr (std::is_floating_point_v<T>) {
        // 浮点类型的处理逻辑
        std::cout << "Float: " << value << std::endl;
    } else {
        // 其他类型的处理逻辑
        std::cout << "Other type" << std::endl;
    }
}

与普通的 if 不同，if constexpr 的条件必须是编译期常量表达式，编译器只会实例化满足条件的分支代码，未选中的分支不会参与编译。

4.3 模板参数推导与类模板参数推导（CTAD）

C++17 引入的类模板参数推导让创建对象变得更简洁：

template<typename T>
class Point {
public:
    T x, y;
    Point(T a, T b) : x(a), y(b) {}
};

// C++17 之前需要显式指定
Point<int> p1(1, 2);

// C++17 起可以自动推导
Point p2(3.5, 4.5);      // Point<double>
Point p3(5, 6);          // Point<int>

// 自定义推导指南
template<typename T>
Point(T, T) -> Point<T>;

五、最佳实践与注意事项

5.1 何时使用模板

模板适用于以下场景：需要在多种类型上执行相同操作的算法、需要创建通用容器或数据结构的库代码、需要编译期计算的性能关键代码。当你的代码中存在大量重复的类型处理逻辑时，模板往往是最佳选择。

5.2 常见陷阱

模板实例化发生在编译期，这意味着错误信息往往非常冗长，包含一长串模板参数列表。学会阅读这些错误信息是掌握模板的重要技能。另外，模板代码应该尽可能减少对模板参数类型的假设，使用 std::enable_if、if constexpr 等机制来处理不同类型的差异。

过于复杂的模板层次会增加编译时间和代码维护难度。模板元编程虽然强大，但过度使用会让代码变得难以理解和调试。在性能收益不明显的情况下，优先选择更直观的实现方式。

5.3 编译优化建议

模板代码全部在头文件中实现是标准做法，因为编译器需要看到完整的模板定义才能进行实例化。将模板声明和实现分离到 .hpp 文件中，然后在使用时包含该头文件。

对于大型项目，启用预编译头文件可以显著减少模板代码的重复编译时间。一些编译器还提供模板实例化控制选项，允许你显式指定需要实例化的模板类型，从而控制编译产物体积。