泛型编程之函数模板

一.概念

泛型编程：通俗的讲就是模版。用一种通用的模板来写程序。

模板：又分为函数模版和类模版，这篇博客主要说的是函数模版。

函数模版：实际上是建立一个和函数，函数的类型和函数的形参类型不具体指定，用虚拟的类型来代表，这个通用的函数就称为函数模版。

(注意：凡是函数体相同的函数都可以用这个模版来代替，不必定义多个函数，只需要在模版中定义一次即可，再调用函数时系统会自己根据实参的类型类取代实参中的具体类型

，从而实现了不同函数的功能)

二.函数模版的实现

首先看一段代码：功能呢是实现char类型和 int 类型的两个变量的交换

void myswap1(int &a, int &b)
{
int c = 0;
c = a;
a = b;
b = c;
}
void myswap2(char &a, char &b)
{
int c = 0;
c = a;
a = b;
b = c;
}
int main()
{
int a = 10;
int b = 20;
char c = 'c';
char d = 'd';
myswap1(a, b);
myswap2(c, d);
cout << "a=" << a << "  b=" << b << endl;
cout << "c=" << c << "  d=" << d << endl;
system("pause");
return 0;
}

上述代码虽然实现了功能，但是显的很麻烦,假如我在多加几个类型就要在定义同样的函数好几个.所以C++就提供了函数模版机制，让类型参数化，方便我们去编程。

首先看看泛型编程函数模版的语法用法：

接下来用代码继续解释：

template <typename T>
void myswap(T &a, T&b)
{
T c;
c = a;
a = b;
b = c;
}
int main()
{
    int a = 10;
    int b = 20;
char c = 'c';
char d = 'd';
//myswap<int>(a, b);//函数模版显示类型调用
//myswap(a, b);//自动类型推倒
myswap<char>(c, d);
 myswap(c, d);
cout << "a=" << a << "  b=" << b << endl;
cout << "c=" << c << "  d=" << d << endl;
system("pause");
return 0;
}

强化应用：对不同类型的数组进行排序

1.int 类型

template <typename T1, typename T2>
void mysort(T1 *arr, T2 sz)
{
T2 i, j;
T1 tmp;
for (i = 0; i < sz - 1; i++)
{
for (j = 0; j < sz - 1 - i; j++)
{
if (arr[j]>arr[j + 1])
{
tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
}
template <typename T1, typename T2>
void print(T1 *arr,T2 sz)
{
T2 i;

        cout << "从小到大排序：";

for (i = 0; i < sz; i++){cout << arr[i] << " ";}cout << endl;}int main(){int arr[] = { 9,8,7,6,5,4,3,2,1};int sz = sizeof(arr) / sizeof(arr[0]);mysort<int, int >(arr, sz);print<int, int >(arr, sz);system("pause");return 0;}

2.测试char 类型

char arr[] = {'f','e','d','c','b','a'};
int sz = sizeof(arr) / sizeof(arr[0]);
mysort<char, int >(arr, sz);
print<char, int >(arr, sz);

自己可以根据自己想测试的类型进行测试~

三.函数模版和函数和普通函数的区别

1.函数模版和函数重载

看如下代码：

template <typename T>
void myswap(T &a, T&b)
{
cout << "我是模版函数" << endl;
}
void myswap(int a, char b)
{
cout << "我是普通函数" << endl;
}
int main()
{
int a = 10;
char b = 'z';
myswap(a, b);
myswap(b, a);
myswap(a, a);
system("pause");
return 0;
}

为什么是这样：1.普通函数的调用，可以进行隐式的类型转换

                             2.函数模版的调用，不会进行隐式的转换。

2.数模版也可以像普通函数一样重载:

①C++编译器优先考虑普通函数

②如果函数模版可以产生一个更好的匹配那么选择函数模版

③可以通过空模版实参列表的语法限定编译器只通过模版匹配

看如下代码：

template <typename T>
void myswap(T a, T b)
{
cout << "我是两个参数的模版函数" << endl;
}
template <typename T>
void myswap(T a, T b,T c)
{
cout << "我是三个参数的函数模版" << endl;
}
void myswap(int a, int b)
{
cout << "我是普通函数" << endl;
}

下面测试调用部分：

int main()
{
int a = 10;
int b = 20;
myswap(a, b);//因为函数模版函数和普通函数同时满足，所以系统优先选择普通函数
myswap<>(a, b);//如果想通过函数模版调用，加上<>（空模版参数列表），就可以调用函数模版函数
myswap(3.0, 4.0);//这个时候只有函数模板函数可以产生更好的匹配，所以调用函数模版函数
myswap(3.0, 4.0, 5.0);//函数模版函数重载
myswap('a', 10);//参数类型不同，而函模版要求参数类型相同，因为普通函数可以进行隐式转换，所以调用普通函数
system("pause");
return 0;
}

结果如下，与上图分析完全符合

四.探究函数模版的机制

1.编译器并不是把函数模版处理成能够处理任意类型的函数

2.编译器从函数模版通过具体类型产生不同的函数

3.编译器会对函数模版进行两次编译：在声明的地方对函数模版代码进行编译，在调用的地方对参数替换后的代码进行编译.

第一次编译：在声明的地方对函数进行词法分析，语法分析，句法分析，产生一个简陋的函数模型。

第二次编译：根据你的调用，产生一个具体的函数原型，如果还有不同参数类型函数模版函数的调用，继续产生一个具体的函数原型。

汇编语言如下图：