函数 模板

函数模板

函数重载和函数模板有着相似的作用，但是函数模板有一些方面上有很大优势。
例如：
将传入的两个值相加


当传入不同类型的数据时，还要将相对应的数据类型的函数实现。那么函数模板就可以只写一个函数就可以处理传入的所有数据类型。
例如：

而模板函数则就是一个函数了，是通过在调用点传入模板类型到虚假模板类性参数列表里，然后函数模板根据这个传入的模板类型就可以实例化一份函数，这个函数就叫做模板函数。
模板的作用就是将类型参数化
如我们传入int类型，则会实例化一份下面的函数：
注意：模板体在编译阶段是不编译的，在调用点才编译，所以我们调试模板的时候，要将所有模板都调用一遍。

模板的实参推演

③：模板的实参推演
例如：
这两种方式都是可以的。

推演过程：在调用点没有模板实例化需要的类型参数，但是通过判断传入的两个实参都是整形int类型的，而且函数模板需要传入的两个类型参数是一致的，则自动推演出来传入整形int类型参数。

模板的实参推演的限制：

不能让编译器产生二义性
要有实参
如果给定一部分类型，另外一部分类型也可以进行实参推演：

模板的特例化

模板的特例化分为两种：

完全特例化（全特化） 应用于：函数模板&类模板
部分特例化（偏特化） 应用于：类模板

1、完全特例化：

//模板的特例化（模板不能满足特殊类型的需求） 全特化
template<typename T>			//函数模板
T Sum(const T a, const T b)
{
	std::cout << "template<typename T> void Show()" << std::endl;
	std::cout << "type:" << typeid(T).name() << std::endl;
	return a + b;
}
 
template<>
char* Sum<char*>(char* const pa, char* const pb)//函数模板全特化<char*>
{
	std::cout << "template<> void Show()" << std::endl;
	std::cout << "type:" << typeid(pa).name() << std::endl;
	int len = strlen(pa) + strlen(pb) + 1;
	char *pnewstr = new char[len]();		//重新开辟一个足够大小的空间
	strcpy(pnewstr, pa);				//先拷贝hello
	strcat(pnewstr, pb);				//接着拷贝world 变成helloworld
	return pnewstr;						//将这个空间地址返回
}
 
int main()
{
	Sum<int>(10, 20);
	Sum<double>(10.1, 10.2);
	char* prt = Sum<char*>("hello", "world");
	std::cout << prt << std::endl;          //打印helloworld
	delete[] prt;							//释放此空间，防止内存泄漏
	return 0;
}

运行结果：

2、部分特例化

//模板的特例化（模板不能满足特殊类型的需求） 偏特化
template<typename T>
class CSum
{
public:
	T Sum(T a, T b)
	{
		std::cout << "1" << std::endl;
		return a + b;
	}
};
 
template<typename T>
class CSum<T*>
{
public:
	T Sum(T* a, T* b)
	{
		std::cout << "2" << std::endl;
		return *a + *b;
	}
};
 
int main()
{
	CSum<int> cs1;
	cs1.Sum(10, 20);
 
	int a = 10;
	int b = 20;
	CSum<int*> cs2;
	cs2.Sum(&a, &b);
 
	double a1 = 10.1;
	double a2 = 10.2;
	CSum<double*> cs3;
	cs3.Sum(&a1, &a2);
	return 0;
}

运行结果：

• 特例化的版本优先级 > 普通模板的版本（类似于有现成的饭，就不必自己做了）
• 特例化的版本是基于普通模板版本的，不能只有特例化的版本而没有普通模板版本。
• 特例化的版本要和普通模板版本的逻辑一致。