1、引入泛型编程
在以前C语言中,如果一个函数要处理不同的数据类型,那么需要为每种数据类型都定义一个函数实行,例如下面的函数:
void Swap(int& a, int& b)
{
int temp = a;
a = b;
b = temp;
}
void Swap(char& a, char& b)
{
char temp = a;
a = b;
b = temp;
}
void Swap(double& a, double& b)
{
double temp = a;
a = b;
b = temp;
}
上面的代码,除了类型不同,函数体完全相同,为了减小重复性,在C++中,有了一个更好的方法来解决这个问题 – 泛型编程!
2、泛型编程
泛型编程的概念
- 不考虑具体数据类型的编程模式
对于上面的Swap函数:
void Swap(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
Swap泛型写法中的 T 不是一个具体的数据类型,而是泛指任意的数据类型。
C++中泛型编程
函数模板
- 提供一种特殊的函数可用不同类型进行调用
- 看起来和普通函数很相似,区别是类型可被参数化
template <typename T>
void Swap(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
函数模板的语法规则
- template关键字用于声明开始进行泛型编程
- typename关键字用于声明泛型类型
函数模板的应用
- 自动类型推导调用
- 具体类型显式调用
示例:
#include <cstdlib>
#include <iostream>
using namespace std;
template<typename T>
void Swap(T& a, T& b)
{
T t = a;
a = b;
b = t;
}
template<typename T>
void SelectSort(T array[], int length)
{
for(int i=0; i<length; i++)
{
T min = array[i];
int index = i;
for(int j=i+1; j<length; j++)
{
if( array[j] < min )
{
min = array[j];
index = j;
}
}
Swap(array[i], array[index]);
}
}
int main(int argc, char *argv[])
{
int array[] = {3, 2, 5, 3 , 4};
SelectSort<int>(array, 5);
for(int i=0; i<5; i++)
{
cout<<array[i]<<endl;
}
char ca[] = {'b', 'c', 'a', 'e', 'd', 'f'};
SelectSort(ca, 6);
for(int i=0; i<6; i++)
{
cout<<ca[i]<<endl;
}
cout << "Press the enter key to continue ...";
cin.get();
return EXIT_SUCCESS;
}
3、函数模板深入理解
- 编译器并不是把函数模板处理成能够处理任意类型的函数
- 编译器还是把函数模板通过具体类型来产生不同的函数
- 编译器会对函数模板进行两次编译
- 在声明的地方对模板代码本身进行编译
- 在调用的地方对参数替换后的代码进行编译
示例:
#include <iostream>
using namespace std;
template <typename T>
void Swap(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
int main()
{
int a = 5, b = 10;
Swap(a,b); //自动推导类型
cout << "a = " << a << '\t' << "b = " << b << endl;
double da = 3.14, db = 1.28;
Swap<double>(da,db); //显式指定类型
cout << "da = " << da << '\t' << "db = " << db << endl;
char ca = 'a', cb = 'z';
Swap(ca,cb); //自动推导
cout << "ca = " << ca << '\t' << "cb = " << cb << endl;
return 0;
}
对于上面的程序,使用如下的命令将其编译成汇编代码:
g++ -S main.cpp
打开生成的汇编代码,搜索函数名Swap,可以找到3个函数,这三个函数就分别对应了源代码中的三次调用,编译器通过不同的类型生成了不同的函数!
4、函数模板与重载
思考:
当函数模板遇上函数重载会发生什么?
- 函数模板可以像普通函数一样被重载、
- C++编译器优先考虑调用普通函数
- 如果函数模板可以产生一个更好的匹配,那么选择模板
- 可以通过空模板实参列表的语法限定编译器只通过模板进行匹配
#include <cstdlib>
#include <iostream>
using namespace std;
int Max(int a, int b)
{
cout<<"int Max(int a, int b)"<<endl;
return a > b ? a : b;
}
template<typename T>
T Max(T a, T b)
{
cout<<"T Max(T a, T b)"<<endl;
return a > b ? a : b;
}
template<typename T>
T Max(T a, T b, T c)
{
cout<<"T Max(T a, T b, T c)"<<endl;
return Max(Max(a, b), c);
}
int main(int argc, char *argv[])
{
int a = 1;
int b = 2;
cout<<Max(a, b)<<endl; //优先匹配普通函数
cout<<Max<>(a, b)<<endl; //通过空模板实参列表,限定匹配模板函数
cout<<Max(3.0, 4.0)<<endl; //自动推导,选择更好的匹配,模板函数
cout<<Max(5.0, 6.0, 7.0)<<endl; //自动推导
cout << "Press the enter key to continue ...";
cin.get();
return EXIT_SUCCESS;
}
运行结果:
注意:
- 函数模板不允许自动类型转换
- 普通函数能够进行自动类型转换
示例:
如果在上述代码中添加:
cout<< Max('a', 100) <<endl;
这里最终会匹配到普通函数上,原因就是函数模板不允许自动类型转换,这里传入的类型为:char 和 int,而模板函数T却只代表一个类型,因此不能调用成功,所以经过转换后为int,并调用普通函数!
5、多参数函数模板
函数模板可以定义任意多个不同的类型参数
类似于上面的问题,如果我们定义两个类型参数,就可以匹配模板函数了,如下:
template<typename Tc, typename Ti,typename Td>
Td Max(Tc a, Ti b)
{
cout<<"Td Max(Tc a, Ti b)"<<endl;
return static_cast<Td>(a + b);
}
cout<< Max<char, float, double>('a', 100) <<endl;
注意:
使用模板函数时,其返回值类型若为类型参数,则无法进行自动类型推导!
比如,上面的模板函数,声明了三个类型参数,返回值类型和其余两个都不一样,这时候就需要我们指明该类型是什么,所以在调用时,使用了显式调用!当然,这里的Tc和Ti还是可以自动推导的,如果想要调用时不指明Tc和Ti的类型,那么可以把返回值类型作为第一个类型参数声明,并在调用时只指明它,如下:
template<typename Td, typename Tc, typename Ti>
Td Max(Tc a, Ti b)
{
cout<<"Td Max(Tc a, Ti b)"<<endl;
return static_cast<Td>(a + b);
}
cout<< Max<double>('a', 100) <<endl;
6、小结
- 函数模板其实是一个具有相同行为的函数家族
- 函数模板可以根据类型实参对函数进行推导调用
- 函数模板可以显示的指定类型参数
- 函数模板可以被重载