demo 1
// 函数的业务逻辑 一样
// 函数的参数类型 不一样
void myswap01(int &a, int &b)
{
int c = 0;
c = a;
a = b;
b = c;
}
void myswap02(char &a, char &b)
{
char c = 0;
c = a;
a = b;
b = c;
}
void main()
{
{
int x = 10;
int y = 20;
myswap01(x, y);
printf("x:%d y:%d \n", x, y);
}
{
char a = 'a';
char b = 'b';
myswap02(a, b);
printf("a:%c b:%c \n", a, b);
}
cout<<"hello..."<<endl;
system("pause");
return ;
}
看到demo 1中的两个函数,他们的逻辑都是一样的,只是参数类型不一样,当然,你可以写函数重载,但还是需要写两个函数,况且函数重载不应该在这种情况下使用。
有了需求,就有了生成,出现了函数模版:
demo 2
//让 类型参数化 ===, 方便程序员进行编码
// 泛型编程
//template 告诉C++编译器 我要开始泛型编程了 .看到T, 不要随便报错
template <typename T>
void myswap(T &a, T &b)
{
T c = 0;
c = a;
a = b;
b = c;
cout << "hello ....我是模板函数,欢迎 call 我" << endl;
}
//函数模板的调用
// 显示类型 调用
// 自动类型 推导
void main()
{
{
int x = 10;
int y = 20;
myswap<int>(x, y); //1 函数模板 显示类型 调用
myswap(x, y); //2 自动类型 推导
printf("x:%d y:%d \n", x, y);
}
{
char a = 'a';
char b = 'b';
//myswap<char>(a, b); //1 函数模板 显示类型 调用
myswap(a, b);
printf("a:%c b:%c \n", a, b);
}
}
此时一个函数定义就完成了,注意调用的时候显示调用使用比较多。
补充一个demo 3
#include <iostream>
using namespace std;
// 函数模板 本质 : 类型参数化
//方便.....
//需要对字符数组 int数组进行排序
template <typename T,typename T2 >
int mySort(T *array, T2 size)
{
T2 i, j ;
T tmp;
if (array == NULL)
{
return -1;
}
//选择
for (i=0; i<size; i++)
{
for (j=i+1; j<size; j++)
{
if (array[i] < array[j])
{
tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
}
}
return 0;
}
template <typename T, typename T2>
int myPrint(T *array, T2 size)
{
T2 i = 0;
for (i=0; i<size; i++)
{
cout << array[i] << " ";
}
return 0;
}
void main()
{
// int类型
{
int myarray[] = {11, 33,44, 33,22, 2, 3, 6, 9};
int size = sizeof(myarray)/sizeof(*myarray);
mySort<int, int> (myarray, size);
printf("排序之后\n");
myPrint(myarray, size);
}
//char 类型
{
char buf[] = "aff32ff2232fffffdssss";
int len = strlen(buf);
mySort<char, int>(buf, len);
myPrint<char , int>(buf, len);
}
cout<<"hello..."<<endl;
system("pause");
return ;
}