C++模板

C++模板

函数模板

前面学过了函数重载，对一个功能我们可以实现不同数据类型的函数重载，给我们编译代码节省了不少麻烦，但是函数重载对于 泛型编程 来说，还是不够高效，因为每次传入的函数类型不同就要重新写一个函数重载。所以就出现了函数模板这种东西，让编译器来完成生成不同数据类型的函数的构建。
函数模板的概念：
函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本
定义函数模板的格式

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

注意：

1. template后面是尖括号<>
2. typename可以用class来替换，顾也可这样写：template<class T1,class T2,class T3.....>

函数模板的实例化

template<class T>  //函数模板声明和定义
void Swap(T& a,T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

int main()
{
	int a = 3;
	int b = 2;
	Swap<int>(a, b);  //实例化一个 int 类型的模板

	double c = 3.14;
	double d = 4.5;
	Swap<double>(c, d);  //实例化一个 double 类型的模板
}

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

隐式实例化在调用的时候，因为不指定类型，所以会带来很多麻烦：
传参时 的参数匹配问题：

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

int main()
{
	int a = 3;
	int b = 2;
	double c = 3.14;
	Add(a, b);
	//Add(a, c);  这种事错误的，编译器无法推演出类型T到底是什么
	Add(a, (int)c);
}

隐式实例化传参数的时候一定要注意模板的类型！！，不能传进去的参数有问题，你以为编译器会对类型隐式转换，但是实际上编译器就会报错。所以这里有两种解决方法：

1. 使用强制类型转换
2. 使用显示实例化

显示实例化：在函数名后用<>来指定实际类型

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

int main()
{
	int a = 3;
	int b = 2;
	double c = 3.14;
	
	Add<int>(a, c);  //这里c就会隐式类型转化成int类型
	Add<double>(a, c); //这里a就会隐式类型转化成double类型
}

这里显示转换后就不需要模板推演了，直接就会生成目标类型的函数，也不会存在什么隐式类型转换的问题，马上讲的模板参数额调用原则时，你就会体会到显示实例化的好处！

模板参数的匹配原则

1. 类型匹配的非模板函数，和模板函数

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

void Swap(int & a, int & b)
{
	int temp = a;
	a = b;
	b = temp;
}

int main()
{
	int a = 3;
	int b = 2;
	
	Swap(a, b);  //这个会调用哪个函数呢？
	Swap<int>(a, b); //显示实例化
}

在没有显示实例化的情况下Swap(a, b); 会调用 模板函数 还是非模板函数？
匹配原则遵循：如果有现成的类型完全匹配非模板函数，会先调用非模板函数！
但是如果你显示实例化模板函数，那就会调用 模板函数！

2. 类型与非模板函数不匹配，则会实例化模板函数

template<class T1,class T2>
void Swap(T1& a, T2& b)
{
	T1 temp = a;
	a = b;
	b = temp;
}

void Swap(int & a, int & b)
{
	int temp = a;
	a = b;
	b = temp;
}

int main()
{
	int a = 3;
	int b = 2;
	double c=3.14；

	Swap(a, b);  // 参数完全匹配调用非模板函数
	Swap(a, c);   // 与非模板参数不匹配 调用 实例化的模板函数
}

如果类型不是完全匹配的话，就会调用模板函数

总结：

优先级：完全匹配 = 显示实例化 > 模板 > 非模板隐式转换

类模板

类模板的定义格式

template<class T1,class T2,.....>
class 类名
{
	//类成员
};

成员函数的定义方式

template<class T>
class A
{
public:
	A();
	~A();

	void fun1()
	{
		cout << "类内定义" << endl;

	}
	void fun2();
private:
	T a;
};

template<class T>
void A<T>::fun2()
{
	cout << "类外定义" << endl;
}

注意：

1. 类模板都是显示实例化！
2. 类模板的成员函数在类外定义的时候要加上模板参数列表！
3. 以前的普通类 类名 = 类型 而 类模板： 类型=类名< T >

模板的分离编译问题

如果你有模拟实现STL容器，有没有发现整个容器的模板类 从声明到成员函数的定义全部放在头文件中，这和我们以前的 声明放在头文件 定义放在另一个文件 不一样。这是由于模板的特殊性质！

我们来验证一下：
首先实现一个分离编译的三个文件：

头文件用来存储一个函数模板，和一个正常函数 的函数声明

fun.cpp用来 存储 两个函数的定义：

最后在test.c中 调用两个函数

结果：

是在编译连接的时候出现了错误。这又涉及到到了编译器对程序的编译连接过程：

1. 首先是在预处理阶段，头文件展开，引用fun.h的文件，就会把fun.h文件在文件中展开，所以
   

2. 在经过 编译 汇编 之后，会生成一张符号表 表中会记录函数名和函数调用地址，
   由于test.cpp中调用了fun模板函数，所以模板函数的类型（也就是符号表中的函数名）被确定了，但是由于没有定义，所以无法实例化，同理 print() 函数 符号表 也会被确定下来。
   而fun.cpp中没有调用fun函数，所以fun根本就不会实例化模板函数，也就相当于，fun.cpp再生成符号表时就不会有fun这个函数
   

3. 最后一步就是链接过程，根据符号表的函数名去寻找函数真正的地址， print很容易就在 fun.cpp中找到了地址3 ,但是fun_int找了一圈发现没有可以匹配的，所以这时链接过程就会报错！
   

所以可以总结出：模板再不被调用的时候 是不会被编译器 编译的，就相当于你写代码时写的注释一样，编译器也不会检查他的语法（但代码过短还是会被检查出来）