C++入门学习：函数模板及其使用，函数模板和普通函数的区别，函数模板的机制

函数模板       

  C++提供了函数模板(function template)。所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体指定，用一个虚拟的类型来代表。这个通用函数就称为函数模板。凡是函数体相同的函数都可以用这个模板来代替，不必定义多个函数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现了不同函数的功能。

具体事例

#include <iostream>

using namespace std;

//函数形参的组成：类型 变量
//参数传递 ========> 将实参传递给形参，做的是变量的传递
//形参 类型参数化 ==========> 函数模板
//模板声明：
//template 用来声明模板用的
//typename 是用来告诉编译器 用来代替类型的名字
template <typename T>
void mySwap(T &a, T &b)
{
	T tmp = a;
	a = b;
	b = tmp;
}

template <typename T>
void print(T &a, T &b)
{
	cout << a << ", " << b << endl;
}

int main()
{
	int a = 10;
	int b = 20;
	mySwap<int>(a, b);//函数模板的显示调用，在<>里面指明传递的类型
	//mySwap(a, b);  //隐式调用，编译器会自动判断传过去的参数类型

	double d1 = 1.2;
	double d2 = 5.6;
	mySwap<double>(d1,d2);

	char c2 = 'B';
	char c1 = 'A';
	mySwap<char>(c1,c2);

	print<int>(a, b);
	print<double>(d1, d2);
	print<char>(c1, c2);

	return 0;
}

模板的好处：

将数据 和 类型 相分离，专注于逻辑功能或者算法的实现，不关心处理数据

eg：冒泡排序模板

#include <iostream>

using namespace std;
//模板：将数据 和 类型 相分离，专注于逻辑功能或者算法的实现，不关心处理数据

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

template <typename T>
void mySort(T *a, int len)
{
	for (int i = 0; i < len-1; i++)
	{
		for (int j = 0; j < len-1-i; j++)
		{
			if (a[j] > a[j+1])
				Swap<T>(a[j], a[j+1]);
		}
	}
}

template <typename T>
void print(T *a, int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << a[i] << " ";
	}
	cout << endl;
}

int main()
{
	int a[] = {16,59,3,51,65,6,38,48,1,9};
	mySort(a, sizeof(a)/sizeof(a[0]));
	print(a, sizeof(a)/sizeof(a[0]));

	char str[] = "dahihdfuqnfkbkfbanfkscixkcoqwoq";
	mySort(str, sizeof(str)/sizeof(str[0])-1);//-1是为了消除末尾的\0
	print(str, sizeof(str)/sizeof(str[0])-1);

	double d[] = {1.2,5.6,6.2, -11.3,9.1,-5.6};
	mySort(d, sizeof(d)/sizeof(d[0]));
	print(d, sizeof(d)/sizeof(d[0]));

	//字符串的比较要通过strcmp进行比较、直接比较大小是字符串地址的比较
	//不是字符串本身的比较
	char *str2[] = {"sdada","njdchi","poifd","amckdv"};
	mySort(str2, sizeof(str2)/sizeof(str2[0]));//排序错误！！！
	print(str2, sizeof(str2)/sizeof(str2[0]));

	return 0;
}

函数模板和普通函数的区别及调用

函数模板不允许自动类型转化

普通函数能够进行自动类型转换

  1 函数模板可以像普通函数一样被重载
  2 C++编译器优先考虑普通函数
  3 如果函数模板可以产生一个更好的匹配，那么选择模板
  4 可以通过空模板实参列表的语法限定编译器只通过模板匹配

#include <iostream>

using namespace std;

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

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

int main1()
{
	int a = 10;
	int b = 20;
	char c = 'A';

	printf("a+b  = %d\n", add(a, b));
	printf("a+b  = %d\n", myAdd(a, b));

	printf("a+c  = %d\n", add(a, c));//会有隐式转换：char----->int

	/*1、在隐式调用的情况下，函数模板不支持变量的隐式转化
	printf("a+c  = %d\n", myAdd(a, c));
	*/
	printf("a+c = %d\n", myAdd<int>(a, c));//在函数显示调用的情况下，参数会被强势转换
	return 0;
}





void print(int a, int b)
{
	cout << a << ", " << b << endl;
}

template <typename T>
void print(T a, T b)
{
	cout << a << ", " << b << endl;
}
//2、函数模板是可以被重载的
template <typename T>
void print(T a, T b, T c)
{
	cout << a << ", " << b << ", " << endl;
}

int main()
{
	print(1,2); //3、在函数模板和普通函数都可以调用的情况下，优先调用普通函数
	print<>(1,2);//4、如果非要调用函数模板，可以通过加一个空参数列表<>或者直接显示调用
	
	print('A', 'B');//5、当函数模板可以提供更好的选择的时候，优先调用函数模板

	print(1,2,3);
}

函数模板的机制

编译器并不是把函数模板处理成能够处理任意类的函数
编译器从函数模板通过具体类型产生不同的函数
编译器会对函数模板进行两次编译

在声明的地方对模板代码本身进行编译；在调用的地方对参数替换后的代码进行编译。

#include <iostream>

using namespace std;

//模板编译
//1、首先对模板本身进行编译------>可以理解成先打造一个模具

template <typename T>//函数模板：用来生产函数的模板
void Swap(T &a, T &b)
{
	T tmp = a;
	a = b;
	b = tmp;
}

/*模板函数：函数模板生产的函数叫模板函数(最后用到多少不同类型的同名函数，就会产生多少模板函数)
void Swap(int &a, int &b)
{
int tmp = a;
a = b;
b = tmp;
}

void Swap(double &a, double &b)
{
double tmp = a;
a = b;
b = tmp;
}

void Swap(char &a, char &b)
{
char tmp = a;
a = b;
b = tmp;
}

*/


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

	//2、在函数调用的地方，根据传入的类型进行函数的生产
	//如果当前已经存在这个函数，则不再生产，如果不存在
	Swap<int>(a, b);
	cout << a << "," << b << endl;

	double d1 = 1.2;
	double d2 = 2.5;
	Swap<double>(d1,d2);
	cout << d1 << "," << d2 << endl;

	char c1 = 'A';
	char c2 = 'C';
	Swap<char>(c1,c2);
	cout << c1 << "," << c2 << endl;

	return 0;
}