【C++初阶】模版初识

目录

函数模板

函数模板格式

多个类型情况：

类模板：

类模版的声明和定义分离：

---

函数模板

在我们写排序的时候时常会用到要交换两个数据的场景：

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;
}
 

就算有函数重载支持一个函数传入不同类型的参数，但是每一种数据类型都要写一个，感觉不是很方便，而且这些函数只有函数参数的类型不一样，其他都一样。

auto虽然可以识别类型，但是不能做参数。

可不可以写一个跟类型无关的代码也叫叫做泛型编程跟类型无关。

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

函数模板格式

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

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

T的位置可以自己命名。

那么对于不同类型使用的时候：

原因：模版函数的推演（由编译器执行）

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

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供 调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然 后产生一份专门处理double类型的代码，对于字符类型也是如此。

 这里函数模版的typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

多个类型情况：

这里的函数的所有参数都是一个类型，如果我们函数参数是多个类型，模版该如何定义：

模版参数是很类似函数参数的，函数参数可以定义多个，模版参数也可以定义多个。只是，函数参数定义的是形式参数对象，模版参数定义的是类型。

template<class T1,class T2>
void func(const T1& x, const T2& y)
{
	cout << x << endl;
	cout << y << endl;
	//这里也凸显了coutC++输入输出流的好处，不仅可以打印自定义类型，而
	//可以配合模版识别打印类型
}

 不能一个模版参数推导成两种类型：比如：

解决方式：

第一种就是将上述模版参数修改成两个。

第二种方式使用强制类型转换：

cout << Add(1, (int)2.2) << endl;

 第三种：以上使用的方式都叫做推演实例化，通过实参传递，去推导模版参数的类型，生成对应的函数。还有一种方式显示实例化：

cout << Add<int>(1, 2.2) << endl;
cout << Add<double>(1, 2.2) << endl;

真正显示实例化场景：

 template<class T>
 T* func1()
 {
	 T* p = new T[10];
	 return p;

 }
 //这个函数没有参数，没法推演函数参数类型，只能显示实例化调用

 template<class T>
 T* func1(int t)
 {
	 T* p = new T[10];
	 return p;

 }
 //这个函数参数类型和模版参数类型推演无关，无法推演。
 int main()
 {
	 double* p = func1<double>();
	 double* p = func1<double>(2);

	 return 0;
 }

函数模板可以和普通函数一起存在不会出现调用歧义：

遵循规则：有合适的就调用更为合适的。 

类模板：

对于一个类的数据，比如我们原先定义的栈类，我要修改栈类存储的数据是int 还是char 最开始都是使用宏定义的方式,这里引入类模版：

类模版只能显示实例化

 template<class T>
 class Stack
 {
 public:
 private:
	 T* _a;
	 int top;
	 int capacity;
 };

 int main()
 {

	 Stack<int> st1;
	 Stack<double> st2;
	 return 0;
 }

普通类：类名就是类型

类模版实例化的类：类名不是类型，类名<数据类型>才是整个类的类型。

     Stack<int> st1;
     Stack<double> st2;

不是同一个类型。显示实例化的类型不同，他们就是不同的类。

类模板只能够推演实例化

构造函数的写法：函数名和类名相同而不是和类型相同：

 Stack(int n = 4)
 {
	 cout << "Stack creat" << endl;
	 _a = new T[n];
	 _top = 0;
	 _capcity = n;
 }
 ~Stack()
 {
	 cout << "Stack destory" << endl;
	 dalete[] _a;
	 _top = 0;
	 _capcity = n;
 }

类模版的声明和定义分离：

要指定类域

template<class T>
class Stack
{
public:
 Stack(int n = 4);
 ~Stack()
 {
	 cout << "Stack destory" << endl;
	 dalete[] _a;
	 _top = 0;
	 _capcity = n;
 }
private:
 T* _a;
 int top;
 int capacity;
};
template<class T>
Stack<T>::Stack(int n )
{
 cout << "Stack creat" << endl;
 _a = new T[n];
 _top = 0;
 _capcity = n;
}

二者放在一个文件中，后续放在两个文件中报错的问题后续知识补充。