C++模板初阶 - 技术栈

1.泛型编程

2.函数模板

[2.1 函数模板概念](#2.1 函数模板概念)

[2.2 函数模板格式](#2.2 函数模板格式)

[2.3 函数模板的原理](#2.3 函数模板的原理)

[2.4 函数模板的实例化](#2.4 函数模板的实例化)

2.4.1隐式实例化

2.4.2显示实例化

[2.5 模板参数的匹配原则](#2.5 模板参数的匹配原则)

3.类模板

[3.1 类模板的定义格式](#3.1 类模板的定义格式)

[3.2 类模板的实例化](#3.2 类模板的实例化)

【揭秘！】这里有你从未听过的独特见解，快来点赞关注，开启智慧之旅

1.泛型编程

泛型编程的核心是使用模板来实现类型参数化，允许代码处理不同类型数据。

泛型编程就相当于是告诉编译器一个模板，让编译器根据不同的类型利用该模板来生成代码。

举个例子：如图，给了一个浇铸模具，我们只需要填充不同颜色的材料，我们就可以得到不同的颜色的铸件。这里给的模具就相当于C++的模板，填充的材料就相当于C++不同的类，得到的铸件就相当于C++生成的具体类型的代码。

泛型编程 ：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编码的基础。

2.函数模板

函数模板是C++实现泛型编码的核心机制之一，它允许编写与具体数据类型无关的代码，从而在不同类型上复用同一套逻辑。

2.1 函数模板概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

2.2 函数模板格式

template<typename T1,typename T2>

template<class T1,class T2>

//上面这两个是一样的，当有多个参数时就用逗号分隔，参数可以为1个，也可以为n个

样式举例：

cpp 复制代码

template<typename T>
void Swap(T& left,T& right)
{
    T temp = left;
    left = right;
    right = temp;
}

注意：typename 是用来定义模板参数关键字，也可以使用class（但是不可以用struct代替class）。

2.3 函数模板的原理

函数模板是一个蓝图，他本身并不是函数，是编译器用使用方式产生特定的具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。

比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将 T 确定为double类型，然后产生一份专门处理double类型的代码。

2.4 函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显示实例化。

2.4.1隐式实例化

让编译器根据实参推演模板参数的实际类型。

cpp 复制代码

template<class T>
T Add(const T& left,const T& right)
{
    return left + right;
}

int main()
{
    int a1 = 10,a2 = 20;
    double d1 = 10.0,d2 = 20.0;
    Add(a1,a2);
    Add(d1,d2);

    //Add(a1,d1);
    //如果写成这样，该语句不能通过编译
    //因为在编译期间，当编译器看到该实例化时，需要推演它的实参类型
    //通过实参a1将T推演为int，通过实参d1将T推演为double类型
    //但是模板中只有一个T
    //编译器无法确定此处到底是将T确定为int还是确定为double类型而报错
    //注意：在模板中，编译器一般会不会进行类型转换操作，因为一旦转化出问题，编译器就要背黑锅了

    //此时有两种处理方式：1.用户自己进行强制转换。2.使用显示实例化(后面进行讲解)
    Add(a1, (int)d1);
    return 0;
}

2.4.2显示实例化

在函数名后面的< >中制定模板参数的实际类型。

cpp 复制代码

int main()
{
    int a = 3;
    int b = 17.00;

    //显示实例化
    Add<int>(a,b);
    return 0;
}

注：如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功，编译器将会报错。

2.5 模板参数的匹配原则

一个非模板函数可以和一个同名函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。

cpp 复制代码

//专门处理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版本
}

对于非模板函数和同名函数，如果其他条件都相同，在调用时会优先调用非模板函数而不会从该模板产生一个实例。如果模板可以产生一个具有更好匹配的函数，那么将选择模板。

cpp 复制代码

//专门处理int的加法函数
int Add(int left,int right)
{
    return left +right;
}

//通用加法函数
template<typename T1,typename T2>
int Add(T1 left,T2 right)
{
    return left + right;
}

void Test()
{
    Add(1,2); //与非函数模板类型完全匹配，不需要函数模板实例化
    Add(1,2.0); //模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
}

函数模板不允许类型自动转换，但是普通函数可以进行自动类型转换。

3.类模板

3.1 类模板的定义格式

template<class T1,class T2>

class 类模板名

{

//类内成员定义

};

cpp 复制代码

#includ<iostream>
using namespace std;

//类模板
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;
};

//模板不建议声明和定义分离到两个文件.h 和 .cpp，会出现链接错误。
template<class T>
void Stack<T>::Push(const T& data)
{
    //扩容
    _array[_size] = data;
    ++_szie;
}

int main()
{
    Stack<int> str1;
    Stack<double> str2;

    return 0;
}

注：类模板的成员函数在类外定义式，必须显示声明模板参数，且类名需包含<T>。

3.2 类模板的实例化

模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟 < > ，然后将实例化的类型放在 < > 中即可，类模板名字在不是真正的类，而是实例化的结果才是真正的类。

所以类模板都是显示实例化。

cpp 复制代码

//Stack是类名，Stack<int>才是类型

Stack<int> st1;

Stack<double> st2;

注：类模板是构建C++泛型库的基石，踏实的代码高度可复用且类型安全。

用心呈现，只为遇见更好的你！点赞关注，让我们的博客陪伴你成长！