模板编程可称范型编程，是一种忽视数据类型的编程方式，这样的好处是什么？且看下面一个例子:
简单使用
求解最值问题，返回两个值中的较大值:
int Max(int a, int b)
{
return a>b?a:b;
}
double Max(int a, int b)
{
return a>b?a:b;
}
string Max(string a,string b)
{
return a>b?a:b;
}
使用Max函数处理数据类型不同的变量时，不得不重复写相同函数体的函数，于是引入了模板编程，可将类型当作未知量，使用template <typename type>来修饰函数:
template <typename type>
type Max(type a, type b)
{
return a>b?a:b;
}
或者
template <class T>
void print(T data)
{
cout << data << endl;
}
这两种声明方法是等价的
调用方法分为隐式调用和显式调用
在main函数中隐式调用:
int main(void)
{
cout << Max(1, 2) << endl;
cout << Max(1.1,2.2) << endl;
cout << Max(string("ILoveYou"),string("IMissYou")) << endl;
return 0;
}
输出:
2
2.2
IMissYou
显式调用，使用<>传类型的参数，也就是在<>填写上数据类型，放到参数和函数名之间
int main(void)
{
cout << Max<int>(1, 2) << endl;
cout << Max<float>(1.1, 2.2) << endl;
cout << Max<string>("ILoveYou","IMissYou") << endl;
return 0;
}
输出:
2
2.2
IMissYou
函数模板
此处着重讨论函数模板和普通函数的使用注意点
如果在代码中存在同名的普通函数和模板函数:
int Max(int a, int b)
{
cout << "comman function..." << endl;
return a > b? a:b;
}
template <class T>
T Max(T a, T b)
{
cout << "function template..." << endl;
return a > b? a:b;
}
那么使用模板的显式调用时，调用的一定是模板函数，隐式调用时，优先调用类型确定的函数
int main(void)
{
cout << Max<int>(1, 2) << endl;
cout << Max(1, 2) << endl;
return 0;
}
如上所示，第一个Max调用模板函数，第二个Max调用普通函数
如果代码中存在同名的模板函数，但参数个数不同:
template <class T1, class T2, class T3>
void print(T1 one, T2 two, T3 three)
{
cout << "three types" << endl;
}
template <class T1, class T2>
void print(T1 one, T2 two, T2 three)
{
cout << "two types" << endl;
}
template <class T>
void print(T one, T two, T three)
{
cout << "one type" << endl;
}
这可以理解为函数模板的重载(类型个数的不同也可以认为是重载)，在显式调用情况下:
int main(void)
{
print<int, double, string>(1, 1.1, string("AAA"));
print<int, double>(1, 1.22, 1.1);
print<int>(1, 2, 3);
return 0;
}
输出:
three types
two types
one type
这里要注意的是，数据类型要和参数匹配
隐式调用略显麻烦，有时发现多个模板都能使用，常常优先调用需要传参较少的函数模板，如下所示:
int main(void)
{
print(1, 1, 1);
return 0;
}
输出 one type
可见类型参数最少的模板(只要传入一个类型)被调用了，但如果参数的类型各不相同，那也只能调用3个类型参数的函数模板了:
int main(void)
{
print(1, 1.1, string("AAA"));
return 0;
}
输出: three types
类中的方法也可以应用函数模板:
class Test
{
public:
template <class T>
void print(T data) {
cout << data << endl;
}
};
同样可以忽视数据类型，调用时通过对象调用即可
函数模板的类型参数可以缺省，这和普通函数参数的缺省是一样的规则，只能从右往左缺省
int main(void)
{
printData<int>(1, string("Hello"));
return 0;
}
这里类型参数就有缺省，但是因为声明了默认参数，所以就将第二个类型认为是string
函数模板还可以向类型参数中传常量:
template <class T,size_t size>
void printArray(T* array)
{
for (int i=0;i<size;i++) {
cout << array[i] << " ";
}
cout << endl;
}
int main(void)
{
int num[3] = {1, 2, 3};
printArray<int, 3>(num);
return 0;
}
输出: 1 2 3
类模板
类也可以应用模板，类模板不是一个完整的类型，所以任何用到类名的地方都要用类名<未知类型>的方式使用，同时在多文件中不能分开写，定义和声明位于同一文件，可以写在.hpp文件中(声明和实现放在一起)，并且类模板只支持显示调用方式
如下案例，对C++结构体使用模板:
template <class T1, class T2>
struct my_pair
{
T1 first;
T2 second;
};
int main(void)
{
my_pair<int,int> pairData = {1, 2};
cout << pairData.first << " " << pairData.second << endl;
my_pair<int, string>* p = new my_pair<int, string>;
p->first = 1;
p->second = "2";
cout << p->first << " " << p->second << endl;
return 0;
}
输出:
1 2
1 2
如下使用类模板:
template <class type1,class type2>
class Test
{
public:
// constructor
Test(type1 one,type2 two):one(one),two(two) {
}
void printTest();
protected:
type1 one;
type2 two;
};
template <class type1,class type2>
void Test<type1,type2>::printTest()
{
cout << one << " " << two << endl;
}
template <class type1, class type2>
class Data :public Test<type1,type2>
{
public:
Data(type1 one, type2 two) :Test<type1,type2>(one,two) {
}
protected:
};
int main(void)
{
Data<int,int> data(1,2);
data.printTest();
return 0;
}
上述代码中首先定义了一个使用template修饰的类模板，声明了变量、构造函数和方法，在实现类模板的方法时也必须加上template进行修饰，在声明Data类继承Test时，也必须加上template修饰，在实例化时，使用<>显式的指定出数据类型
