模板初阶

模板，也就是函数模板，调用实例化后才会成为函数。

基本语法

没使用模板前，我们为了适配不同的数据类型，需要写三个甚至更多的Swap函数，但他们的逻辑是类似的，甚至完全一样。

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

代码1↑

使用模板后

//模板
template<typename T>
void Swap(T& left, T&right)
{T temp = left;left = right;right = temp;
}int main()
{int x = 0, y = 1;double m = 1.1, n = 2.2;//调用Swap(x, y);Swap(m, n);return 0;
}

代码2↑

①typename是关键字。也可以用class，两者有些许区别，后面再讲。
②T为模板参数，可以有多个模板参数，逗号分隔，模板参数在实例化时可替换为数据类型，同一个模板参数只能替换为同一个数据类型。
③调用时，编译器会根据传入参数推演，把T替换为对应的数据类型，由编译器帮助生成实例化函数。Swap（x，y）会实例化为代码1中的第一段Swap，Swap（m，n)会实例化为第二段Swap，调用的是不同的函数。

函数模板的实例化

分为隐式实例化和显式实例化。

//模板
template<typename T>
void Swap(T& left, T&right)
{T temp = left;left = right;right = temp;
}//隐式实例化
Swap(x, y);
Swap(m, n);
//或者自行强制类型转化
Swap(x, (int)n);
Swap((double)x, n);//显式实例化
Swap<int>(x, m);
Swap<double>(x, m);

隐式实例化：编译器根据实参推演模板参数的实际类型。
显式实例化：用尖括号<>指明模板参数的替换。

显式实例化的作用

T func(size_t n)
{return T;
}

如上函数，代码无法通过函数参数推演出模板参数要替换成的实际类型，因此需要显式实例化指明类型。

func<int>(2);

tips1：如果运行代码Add(2, 3)，程序会调用哪段代码？

int Add(int a, int b)
{return a + b;
}template<class T>
T Add(T a, T b)
{return a + b;
}

会调用第一段代码，有现成的用现成的，减少推演的步骤，提高效率。
如果非要调用模板，那就运行代码Add<int>(2, 3)，用显式实例化让程序使用模板。

tips2：如果运行Add(1.1, 2)，就运行第三段模板代码；如果运行Add(1.1, 2.2)，就运行第二段模板代码


int Add(int a, int b)
{return a + b;
}template<class T>
T Add(T a, T b)
{return a + b;
}template<class T1, class T2>
T1 Add(T1 a, T2 b)
{return a + b;
}

哪个方便用哪个。

类模板

与函数模板用法十分类似。

基本语法

template<typename T>
{
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;//········
}

同上：
①是模板，不是实体，需要实例化。
②分为隐式实例化和显式实例化。
③同一模板参数替换的数据类型不同的时候，实例化出来的对象不属于同一类。
④哪个模板方便推演用哪个，有现成的就用现成的。