函数模板

写最简单的求和函数如下所示：

int Sum(int a,int b)
{
       return a+b;
}

那如果我们求double呢？在C语言中我们用到泛型编程，也可以通过函数重载实现，但是代码重复性大，工作量大。还有可以用宏实现，#define Sum（a+b）没有类型检查。

在C++中模板专门可以解决这类问题。模板有2类：函数模板和类模板。

函数模板主要有以下几方面：

1、函数模板

2、模板的实例化（显示实例化、隐式实例化）

3、模板函数

4、模板的实参推演

5、模板的类型参数&非类型参数

6、模板的特例化（专用化）

7、模板函数的重载

函数模板就是把类型参数化，其形式如下：

template<typename T>
T Sum(T a,T b)
{
          return a+b;
}

模板是不编译的，那它是怎么变成函数呢？

扫描到函数模板时只编译模板头部，在函数调用点，实例化（类型实参传入模板形参列表，生成模板函数的过程）出一份代码，这份代码称为模板函数，对模板函数进行编译编译。

int Sum<int>(int a,int b)
{
        return a+b;
}

Sum是模板名，加上类型之后Sum<int>是函数名。

//函数模板
#if 0
template<typename T>
bool compare(T a,T b)
{
	cout<<typeid(T).name()<<endl;
	cout<<typeid(a).name()<<endl;
	cout<<typeid(a).name()<<endl;
	cout<<"template compare"<<endl;
	return a>b;
}

int main()
{
	compare<int>(10,20);//函数名为模板名+类型
	//调用点实例化出一份代码

	compare<double>(9.7,10.5);

	compare(10,20);//模板的实参推演:通过实参的类型推演出模板的类型参数
	//compare(10,20.5);实参类型不一样，会产生二义性，不能推演
	//T fun(){};没有实参不能推演
	compare<int>(10.5,10);//规定了第一个参数强转成int，第二个参数推演出int
	//以上的实例化都是隐式实例化

	return 0;
}
#endif

#if 0
template<typename T>
bool compare(T a,T b);
//在另外的一个.cpp文件中定义一个模板，在本文件声明，这样调用会出现一个连接错误
//模板不进行编译，没有任何实例化，没有产生任何的函数
//模板的实例化是在编译阶段，每个文件单独编译
//写到头文件中
//显示实例化

int main()
{
	compare(10,20);
	return 0;
}
#endif

#if 0
//typename定义的称为类型参数，int LEN称为非类型参数
//非类型参数必须是一个常量，不能传入double、float和类类型
template<typename T,int LEN>
void sort(T arr[])
{
	int i = 0;
	int j = 0;
	T tmp = T();//零初始化/零构造-》内置类型：0，自定义类型：调用默认构造函数  不能简单的初始化0
	for(;i < LEN-1; i++)
	{
		for(; j < LEN-i-1; i++)
		{
			if(arr[j] > arr[j+1])
			{
				tmp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = tmp;
			}
		}
	}
}
int main()
{
	int array[10];
	for(int i=0; i<10; i++)
	{
		array[i] = rand()%100 + 1;
	}
	//sort<int>(array,10); 
	sort<int,10>(array);

	return 0;
}
#endif

#if 0
template<typename T>
bool compare(T a,T b)
{
	cout<<typeid(T).name()<<endl;
	cout<<typeid(a).name()<<endl;
	cout<<typeid(a).name()<<endl;
	cout<<"template compare"<<endl;
	return a>b;
}
//模板的特例化/专用化  -->解决模板不能完全处理的某些类型的逻辑代码
//函数模板只支持模板的完全特例化，不支持部分特例化
template<>//不能省略，表示是特例化，<>不能传参
bool compare<char*>(char* a,char* b)
{
	cout<<"compare<char*>(char*,char*)"<<endl;
	return strcmp(a,b);
}

//普通函数
bool compare(int a,int b)
{
	cout<<"compare<char*>(char*,char*)"<<endl;
	return a>b;
}
//模板函数的重载：普通函数 > 特例化函数 > 实例化函数

int main()
{
	compare(10,20);
	compare<char*>("hello","world");//const char* //调用特例化版本
	//字符串不能a>b来比较 --》模板特例化/专用化
	compare("hello","world");//实例化 compare<const char*> 和 compare<char*> 不匹配

	return 0;
}
#endif

#if 0
template<typename T>
bool compare(const T a,const T b)
{
	cout<<typeid(T).name()<<endl;
	cout<<typeid(a).name()<<endl;
	cout<<typeid(a).name()<<endl;
	cout<<"template compare"<<endl;
	return a>b;
}
//模板的特例化必须和函数模板要表达的逻辑相同
//如果T直接替换成char*，特例化出来就是const char* a，const修饰*a，但实际上模板就是的是a
template<>
bool compare<char*>(char* const a,char* const b)
{
	cout<<"compare<char*>(char*,char*)"<<endl;
	return strcmp(a,b);
}
#endif

#if 0
template<typename T>
int findValIndex(T *array,int length,const T &val)
{
	for(int i = 0; i < length; ++i)
	{
		if(array[i] == val)
			return i;
	}
	return -1;
}
template<>
int findValIndex<char*>(char** array,int length, char* const &val)
{
	for(int i = 0; i < length; ++i)
	{
		if(strcmp(array[i],val) == 0)
			return i;
	}
	return -1;
}
int main()
{
	int array[] = {2,45,6,78};
	int length = sizeof(array)/sizeof(array[0]);
	int index = -1;

	index = findValIndex(array,length,78);
	if(index == -1)
		return -1;
	cout<<index<<endl;

	char* str[] = {"hello","world","hellncksd"};
	length = sizeof(array)/sizeof(array[0]);
	index = findValIndex<char*>(str,length,"hello");
	if(index == -1)
		return -1;
	cout<<index<<endl;

	return 0;

}
#endif