泛型程序设计
算法实现时不指定具体要操作的数据的类型。适用于多种数据结构。
函数模板
Template <class 类型参数1，class类型参数2,…..>
返回值类型 模板名（形参表）
{
函数体；
}
函数模板可以重载，只要它们的形参表不同即可。
C++编译器遵循以下优先顺序：
- 先找参数完全匹配的普通函数（非由模板实例化而得的函数）
- 再找参数完全匹配的模板函数
- 再找实参经过自动类型转换后能匹配的普通函数
- 上面的都不符合则报错。
可以在函数模板中使用多个类型参数，可以避免二义性。
#include <iostream>
using namespace std;
void M(int &a, int &b)
{
cout << "M1 is called" << endl;
}
template <class T>
void M(T &a, T &b)
{
cout << "M2 is called" << endl;
}
template <class T1, class T2>
void M(T1 &a, T2 &b)
{
cout << "M3 is called" << endl;
}
int main()
{
int a=0, b=0;
double c = 0, d = 0;
int e = 0; float f = 0;
M(a, b);
M(c, d);
M(e, f);
return 0;
}
运行结果：
类模板
- 在定义类的时候给它一个/多个参数
- 这个一个/多个参数表示不同的数据类型
调用类模板时，指定参数，由编译系统根据参数提供的数据类型自动产生相应的模板类。
类模板的定义
Template <类型参数表>
Class 类模板名
{
成员函数和成员变量
}
类型参数表的写法就是：
Class 类型参数1，class 类型参数2，….
- 类模板里的成员函数，如在类模板外面定义时，
Template<类型参数表>
返回值类型 类模板名<类型参数名列表>::成员函数名（参数表）
{
…..
}
用类模板定义对象的写法如下：
类模板名<真实类型参数表> 对象名（构造函数实际参数表）；
如果类模板有无参构造函数，那么也可以只写：
类模板名 <真实类型参数表>对象名；
使用类模板声明对象
编译器由类模板生成类的过程叫类模板的实例化
- 编译器自动用具体的数据类型替换模板中的类型参数，生成模板类的代码
- 由类模板实例化得到的类叫模板类。为类型参数指定的数据类型不同，得到的模板类不同。
同一个类模板的两个模板类是不兼容的
Pair<string,int> *p;
Pair<string,double> a;
p=&a//wrong;
类模板与非类型参数
类模板的参数声明中可以包括非类型参数
Template<class T, int elementsNumber >
- 非类型参数：用来说明类模板中的属性
- 类型参数：用来说明类模板中的属性类型，成员操作的参数类型和返回值类型。
cArray<int, 50> 和cArray<int , 40>完全是两个类，这两个类的对象之间不能互相赋值。
类模板与继承
- 类模板派生出类模板，派生类模板的类型参数名列表中应包含基类模板的参数
- 模板类（即类模板中类型/非类型参数实例化后的类）派生出类模板
- 普通类派生出类模板
- 模板类派生出普通类
类模板派生出类模板
Template <class T1, class T2>
Class A
{
T1 v1;T2 v2;
}
Template <class T1, class T2>
Class B:public A<T2, T1>
{
T1 v3;T2 v4;
}
Template<class T>
Class C:public B<T,T>
{
T v5;
}
模板类派生出类模板
Template <class T1, class T2>
Class A{T1 v1; T2 v2};
Template <class T>
Class B :public A<int, double>{T v};
普通类派生出类模板
Class A
{
int m;
}
Template <class T>
Class B:public A
{
T v;
}
模板类派生出普通类
Template <class T1, class T2>
Class A{T1 v1; T2 v2};
Class B ：public A<int ,double>
{
int v;
}
类模板实例：
#include <iostream>
#include <string>
using namespace std;
template <class T1, class T2>
class Pair
{
public:
T1 key;
T2 value;
Pair(T1 key, T2 value) :key(key), value(value) {}
bool operator <(const Pair<T1, T2> &p) const;
};
template <class T1, class T2>
bool Pair<T1,T2>::operator<(const Pair<T1, T2> &P) const
{
return (value < P.value);
}
int main()
{
Pair<string, int> student("Tom", 19);
cout << student.key << " " << student.value << endl;
return 0;
}
参考链接：
https://www.coursera.org/learn/cpp-chengxu-sheji