【C++模板】：开启泛型编程之门（函数模版，类模板）

📝前言：
在上一篇文章C++内存管理中我们介绍了C++的内存管理，重点介绍了与C语言的区别，以及new和delete。这篇文章我们将介绍C++的利器——模板。
在C++编程世界里，模板是一项强大的特性，它为泛型编程奠定了坚实基础。借助模板，我们能够编写出与类型无关的通用代码，极大地提升代码复用性，减少重复劳动。接下来，让我们深入探索C++模板的奥秘。

🎬个人简介：努力学习ing
📋个人专栏：C++学习笔记
🎀CSDN主页 愚润求学
🌄其他专栏：C语言入门基础，python入门基础，python刷题专栏

一、函数模板

1. 函数模板概念与格式

函数模板就像一个函数家族的蓝图，该函数模板与类型无关，在使用时被参数化，编译器根据实参类型产生函数的特定类型版本。其格式如下：

template<typename T1, typename T2,......,typename Tn> 
返回值类型 函数名(参数列表){
    // 函数体
}

其中，typename是定义模板参数的关键字，也可用class替代（注意不能用struct）。例如，实现一个通用的加法函数模板：

template<typename T> // 只有一
T Add(const T& left, const T& right) {
    return left + right;
}

2. 函数模板原理

函数模板本身并非真正的函数，而是编译器用于生成具体类型函数的模具。在编译阶段，编译器会依据传入的实参类型，推演并生成相应类型的函数。比如：

int main() {
    int a = 10, b = 20;
    double c = 10.0, d = 20.0;
    Add(a, b); // 编译器将T推演为int，生成处理int类型的Add函数
    Add(c, d); // 编译器将T推演为double，生成处理double类型的Add函数
    return 0;
}

比如swap函数：

3. 函数模板实例化

当程序中调用函数模板并为类型参数指定具体类型时，编译器会根据该类型生成一个特定的函数实例。每个实例都是一个独立的函数，可以像普通函数一样被调用和执行。

• 隐式实例化：让编译器根据实参自动推演模板参数的实际类型。不过，当实参类型无法唯一确定模板参数时会报错。例如：

int main() {
    int a = 10;
    double b = 20.0;
    // Add(a, b);  // 报错，无法确定T的类型（因为在这个模板的参数列表里面只有一个参数）
    // 解决方法一：用户强制类型转换
    Add(a, (int)b);
    // 解决方法二：使用显式实例化
    Add<int>(a, b)
    return 0;
}

• 显式实例化：在函数名后的<>中明确指定模板参数的实际类型。如：

int main() {
    int a = 10;
    double b = 20.0;
    Add<int>(a, b); 
    return 0;
}

多个参数的函数模版实例：

#include <iostream>

// 函数模板，接受多个参数并打印它们
template<typename T1, typename T2, typename T3>
void printMultiple(const T1& a, const T2& b, const T3& c) {
    std::cout << "Values are: " << a << ", " << b << ", " << c << std::endl;
}

int main() {
    int intValue = 1;
    double doubleValue = 2.5;
    char charValue = 'A';

    printMultiple(intValue, doubleValue, charValue);
	// 显式实例化：printMultiple<int, double, char>(intValue, doubleValue, charValue);
    return 0;
}

4. 模板参数匹配原则

• 一个非模板函数可以和同名函数模板共存，且函数模板能实例化为该非模板函数。
• 调用时，若其他条件相同，优先调用非模板函数；若模板能生成更匹配的函数，则选择模板。
• 模板函数不允许自动类型转换，普通函数可以。例如：

// 专门处理int的加法函数
int Add(int left, int right) {
    return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right) {
    return left + right;
}
void Test() {
    Add(1, 2); // 调用非模板函数
    Add<int>(1, 2); // 调用模板函数实例化版本
    Add(1, 2.0); // 调用模板函数生成的更匹配版本
}

二、类模板

1. 类模板定义格式

template<class T1, class T2, ..., class Tn>
class 类模板名 {
    // 类内成员定义
};

以实现一个简单的栈类模板为例：

template<typename T>
class Stack {
public:
    Stack(size_t capacity = 4) {
        _array = new T[capacity];
        _capacity = capacity;
        _size = 0;
    }
    void Push(const T& data);
private:
    T* _array;
    size_t _capacity;
    size_t _size;
};
template<class T>
void Stack<T>::Push(const T& data) {
    // 扩容逻辑
    _array[_size] = data;
    ++_size;
}

注意：类模板中可以定义成员函数模版，但是类模板里面的成员函数不一定是函数模版。

2. 类模板实例化

类模板实例化必须是显式实例化，即：需要在类模板名字后跟<>，并将实例化类型置于其中。类模板本身不是真正的类，实例化结果才是。例如：

int main() {
    Stack<int> st1; // 实例化出处理int类型的栈
    Stack<double> st2; // 实例化出处理double类型的栈
    return 0;
}

注意：模版不建议声明和定义分离到两个文件.h和.cpp，会出现链接错误

🌈我的分享也就到此结束啦🌈
要是我的分享也能对你的学习起到帮助，那简直是太酷啦！
若有不足，还请大家多多指正，我们一起学习交流！
📢公主，王子：点赞👍→收藏⭐→关注🔍
感谢大家的观看和支持！祝大家都能得偿所愿，天天开心！！！