模板初识【C++】

---

泛型编程

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

对于swap()函数，在C语言中我们可能需要修改命名来适配不同类型的swap()函数，在学习函数重载后，我们可以编写不同参数的swap()函数，但对于不同的类，每次我们都需要写swap()函数，还是会觉得麻烦，有了模板之后，可以用一套模具来生成不同swap()函数，进一步使代码复用

// C语言
void Swap_int(int* a, int* b);
void Swap_double(double* a, double* b);

// 函数重载
void Swap(int& a, int& b);
void Swap(double& a, double& b);

// 模板
template<typename T>
void Swap(T& a, T& b)
{
    T temp = a;
    a = b;
    b = temp;
}
// 由模板生成
Swap<float>(1.0, 2.0); // 调用float类型
Swap<int>(1, 2); // 调用int类型

函数模板

概念

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

函数模板是一个蓝图，不是函数，是编译器产生特定具体函数的模具，只是将原本程序员所做的重复的事交给编译器去做

在编译阶段，编译器会根据传入的实参类型生成对应类型的函数以供调用

格式

template<typename T1, typename T2,.....,typename Tn>

返回值类型 函数名(参数列表) {}

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

typename是定义模板参数关键字，也可使用**class**

实例化

1. 隐式实例化-让编译器根据实参推演模板参数的实际类型

// 以上述Swap()为例
int main()
{
    int a1 = 10, a2 = 20;
    double d1 = 10.0, d2 = 20.0;
    Swap(a1, a2);
    Swap(d1, d2);
    // Swap(a1, d2); // 这个是错误的，因为编译器不能确定参数T是int还是double
    // 可以使用强转或者显示实例化
    Swap(a1, (int)d1);
    Swap(d1, (double)a2);
    
    return 0;
}

2. 显示实例化-在函数名后的<>中指定模板参数的实际类型

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

匹配原则

一个非模板函数可以和一个同名的函数模板同时存在，如果可以调用非模板函数，在调用时会优先调用非模板函数

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}

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

int main()
{
	int a = 0, b = 10;
	Swap(a, b); // 与非模板函数匹配，编译器不需要实例化
	Swap<int>(a, b); // 调用编译器实例化的Swap版本

	return 0;
}

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

类模板

格式

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

// 动态顺序表
// Vector不是具体的类，是编译器根据呗实例化的类型生成具体类的模具
template<class T>
class Vector
{
public:
	Vector(size_t capacity = 10)
        :_pData(new T[capacity])
        , _size(0)
        , _capacity(capacity)
    {}
    
    //析构函数在类外声明，定义在类外实现
    ~Vector();
    
    void PushBack(const T& data)
    {
        // ....
    }
    
private:
	T* _pData;
    size_t _size;
    size_t _capacity;
}

// 析构函数定义
template<class T>
Vector<T>::~Vector()
{
    if (_pData)
        delete[] _pData;
    _size = _capacity = 0;
}

实例化

// Vector是类名，Vector<int>才是类型
Vector<int> s1;
Vector<double> s2;