函数模板
实现一个函数对应多种形参
声明方式:
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
类实现动态数组