C++——函数模板相关知识

本文章将对模板函数的相关内容进行说明，如有不足，欢迎指正。

函数模板的知识点可以分为以下几点：

1. 函数模板

2. 函数模板的作用域

3. 函数模板的显式隐式实例化

4. 函数模板的重载

5. 非模板函数

 

函数模板具有以下特征：

1. 函数模板本身不进行编译，实例化出的函数代码则要进行编译

2. 函数模板类型自推，能够根据参数类型自动推演出模板类型

3. 编译时期根据模板调用的类型方式，自动生成一份对应于该类型的代码(模板的实例化)

4.模板的作用域只在当前文件，通过引用其他文件的头文件与声明也无法编译

5.函数调用的优先级：非模板函数->特例化函数->模板函数

 

注：

#define char* CharPtr 字符替换，不进行类型检查
typedef char* CharPtr; 重命名数据类型
const CharPtr a;  字符替换，const修饰的是char

 

详细内容请看以下相关代码

代码示例1：

#include 
#include 
#include 
#include 
using namespace std;

/*函数模板的显式实例化
template bool compare(int a, int b);
template bool compare(double a, double b);
*/ 

//T是一种类型
//函数模板的隐式实例化
/*
template
bool compare(T a, T b)
{
	cout<<"bool compare(T a, T b)"<b;
}
*/

//函数模板
template
bool compare(const T a, const T b)
{
	cout<<"bool compare(const T a, const T b)"< b;
}

//函数，模板的特例化
typedef char* CharPtr;
template<>
bool compare(const CharPtr a, const CharPtr b)
{
	cout<<"bool compare(const CharPtr a, const CharPtr b)"< 0;
}

//非模板函数
bool compare(const double a, const double b)
{
	cout<<"bool compare(const double a, const double b)"< b;
}

/*
//函数模板的特例化 error,正确的做法是将char*替换成CharPtr,这样const修饰的就为char*整体了
template<>
bool compare(const char* a, const char* b)//const修饰的是char
{
	cout<<"bool compare(const char* a, const char* b)"< 0;
}
*/


//模板函数的重载，实现数组的比较
template
bool compare(T* arr1, int len1, T* arr2, int len2)
{
	cout<<"bool compare(T* arr1, int len1, T* arr2, int len2)"< arr2[j])
		{
			return true;
		}
	}
	if(i == len1)  //arr1 < arr2
	{
		return false;
	}
	return true;
}


int main()
{
	int a = 10;
	int b = 20;

	compare(a, b);//模板函数

	compare(10.2, 13.2);//非模板函数

	compare("hello", "world");//模板函数特例化

	compare("hello", 5, "world", 5);  //模板函数的重载
		
	return 0;
}

代码示例2：

#include 
#include 
#include  //产生随机数的头文件
#include   
using namespace std;

//1模板函数
//冒泡排序
template
void boobleSort(T arr[], int len)
{
	int i,j;
	T tmp;
	for(i=0; i
void boobleSort(char* arr[], int len)
{
	int i,j;
	char* tmp;
	for(i=0; i
bool myLess(T a, T b)
{
	cout<<"bool myless(T a, T b)"<
bool myLess(char* a, char* b)
{
	cout<<"bool myLess(char* a, char* b)"<
void boobleSort(T arr[])
{
	cout<<"void boobleSort(T arr[])"<
void boobleSort(T arr[], int len, PRE pre)
{
	cout<<"void boobleSort(T arr[], int len, PRE pre)"<(arr);

	for(i=0; i<10; i++)
	{
		cout<(arr1);
	for(i=0; i<3; i++)
	{
		cout<

代码示例3（对示例2的改进与简化版）：

#include 
#include 
#include 
using namespace std;

//模板函数
template
bool Myless(T a,T b)
{
	return a < b;
}

//模板的特例化
template<>
bool Myless(char* a, char* b)
{
	return strcmp(a,b) < 0;
}

//模板函数
template
bool Mygreater(T a,T b)
{
	return a > b;
}

//模板的特例化
template<>
bool Mygreater(char* a, char* b)
{
	return strcmp(a, b) > 0;
}

//类型作为模板类型参数
template
void Msort(T *arr, int len, PRE pre)
{
	T tmp;
	for(int i=0; i arr[j])//由小到大
			//if(arr[i] < arr[j])//由大到小
			//if(Mygreater(arr[i], arr[j]))
			//if(Myless(arr[i], arr[j]))
			if(pre(arr[i], arr[j]))
			{
				tmp = arr[i];
				arr[i] = arr[j];
				arr[j] = tmp;
			}

		}
	}
}

int main()
{
	srand(time(0));
	int arr[10] = {0};
	for(int i=0; i<10; i++)
	{
		arr[i] = rand()%100+1;
	}
	Msort(arr,10,Myless);
	for(int i=0; i<10; i++)
	{
		cout<