11 模板

函数模板

实现一个函数对应多种形参
声明方式：

template <calss 类型参数>
template <typename 类型参数>

注意：在这紧接着的函数无论是否使用类型参数，都是函数模板而不是普通函数
template只能作用一个函数，也就是需要写一个template一个函数

》实例化模板：

方式一：默认形式，根据传递的实参类型确定
e.g.求数组中最大元素

template<class T>
T maxmum(T* a, int size)
{
	T max = a[0];
	for (int i = 1; i < size; i++)
	{
		if (max < a[i])max = a[i];
	}
	return max;
}

甚至可以实现，字符数组的查找
可以实现的main函数距离：

int main()
{
	char a0[20] = "1234";
	int a1[3] = { 1,2,3 };
	double a2[4] = { 1,2,3,4 };
	cout << maxmum(a0, strlen(a0)) << endl;
	cout << maxmum(a1, 3) << endl;
	cout << maxmum(a2, 4) << endl;
}

方式二：不通过参数实例化函数模板,在使用函数时规定函数类型

T plus1(T n)
{
	return (n + 1);
}
int main()
{
	int n = 4;
	cout << plus1(n) / 2<<endl;
	cout << plus1<double>(n) / 2 << endl;
}

输出
2
2.5 类型被修改为double

》函数模板的重载

按照参数个数，参数类型的不同可以实现重载
e.g.按照参数类型不同

template<calss T>
void add(T a,T b);
template<class T1,class T2>
void add(T1 x,T2 y);

》调用顺序

重：
1）普通函数
2）类型符合的函数模板
3）经过类型转换后可以使用的普通函数
注意：
使用函数模板的时候不会自动进行类型转换
e.g.

#include<iostream>
using namespace std;
bool comp(int a, int b)
{
	cout << "普通" << endl;
	return a > b ? true: false;
}
template<class T>
bool comp(T a, T b)
{
	cout << "模板" << endl;
	return a > b ? true:false;
}
int main()
{
	int a = 1, b = 2;
	double c = 3,d=4;
	char e = 'e';
	comp(a, b);
	comp(c, d);
	comp(a, c);
}

输出
普通
模板
普通

函数指针

e.g.实现sort函数
1）定义比较函数

bool cmpasc(int a, int b)
{
	bool n;
	a > b ? n = true : n = false ;
	return n;
}
bool cmpdes(int a, int b)
{
	bool n;
	a < b ? n = true : n = false;
	return n;
}

2)sort函数
利用函数指针实现函数作为参数被sort函数调用

void sort(int*a,int size,bool(*cmp)(int,int))
{
	for (int i = 0; i < size - 1; i++)
		for (int j = 1; j < size; j++)
			if (cmp(a[i], a[j]))
				swap(a[i], a[j]);
}

测试主函数

void out(int* a, int size)
{
	for (int i = 0; i < size; i++)
		cout << a[i] << ' ';
	cout << endl;
}
int main()
{
	int a[4] = { 1,2,3,4 };
	sort(a, 4, cmpdes);//降序
	out(a, 4);
	sort(a, 4, cmpasc);//升序
	out(a, 4);
}

与函数模板联系：
函数参数类型不定时，函数模板
函数内部计算不定时，函数指针

类模板

》定义：
1）类模板不是真正的类类型
只是定义了一组类型通用的样板，也因为类型没有确定，不能够使用类模板直接创建对象
2）类模板的实例化
类模板实例化之后再能创建对象
模板类：类模板实例化得到的类
且
实例化之后的模板类属于不同的类，互相不兼容

Store<int> S1, S2; 
Store<Student> S3;
S1=S3; //error

》使用

#include <iostream>
using namespace std;
template<class T>
class A
{
public:
template<class T2>和类的类型不一样，方便使用
void Func( T2 t);成员函数模板
};
template<class T2>
template<class T>
void A<T>Func::(T2 t)
{ cout << t; } 
int main()
{
A<int> a;
a.Func(‘k’); //成员函数模板Func被实例化
a.Func(“hello”); //同上
return 0；
}

注意：Fun函数的类型参数在声明的时候和类的类型参数是分开的
在类外定义Func函数，不能将两个类型参数合并，会报错与声明不符

e.g
类实现动态数组