C++ 面向对象编程7 模板
概念
模板作用强大且复杂，由于水平有限本文只做简单讲解和使用。模板的作用就是实现类型通用，降低代码的冗余度模板可以为一种算法定义适用不同类型的版本，实现机制：
1.使用类型参数摆脱类型的限制，丧失了一定的类型安全；
2.模板要实例化才能使用，实例化由编译器来实现的。
分类
函数模板
函数模板就是带类型参数的函数，函数的返回值，局部变量，形式参数都可以使用类型参数，函数模板支持类型推断(形参)。
函数模板 ---> 实例化 ---> 函数
编译
类模板
类模板就是带类型参数的类，类的成员变量，成员函数，成员类型都可以使用类型参数，类模板不支持类型推断。
类模板 ---> 实例化 ---> 类 ---> 实例化 ---> 对象
编译 运行
使用
函数模板
语法：
//函数模板定义
template<typename T/*类型参数*/....>
返回值类型 函数模板名(形参列表)
{
.......//函数中可以使用类型参数T作为类型
}
//函数模板的调用
函数模板名<类型...>(实参);//如果类型参数可以通过实参推断出来，传递的类型参数可以省略
类模板
语法：
//类模板的定义
template<typename T/*类型参数*/....>
class 类模板名{
........//类的成员可以使用类型参数T作为类型
};
//类模板的使用
类模板名<类型...> 对象名; //类模板不支持类型推断
模板的特化
如果模板对某些特殊的类型的行为需要重新定义，此时可以进行模板特化；比如创建一个用于比较大小的函数模板，无论是int型还是float型、char型都可以通用，但是对于char*(字符串)，是不能使用这个模板的，所以需要对这个模板进行特化，当传入的参数是char *则调用重新定义的模板，而不是使用之前通用类型的模板，对于类模板也是一样，因为有一些类型的运算和通用模板不符也需要进行特化，语法如下：
//函数模板特化
template<>
返回值类型 函数模板名<特化的类型...>(形参列表)
{
.....//使用特化的类型
}
//类模板特化
template<>
class 类模板名<特化的类型...>{
........//类的成员使用特化类型作为类型
};
编译器在对模板实例化时，如果原模板和特化模板同时符合，优先选择特化的模板。
实验程序：
#include <iostream>
#include <string>
#include <cstring>
using namespace std;
//函数模板
template <typename T>
T mymax(const T a, const T b)
{
return a > b ? a : b;
}
//函数模板特化
template<>
const char * mymax<const char *>(const char *str1, const char *str2)
{
return strcmp(str1, str2) > 0 ? str1 : str2;
}
//类模板
template <typename T>
class comparator{
public:
comparator(T a, T b):a(a),b(b){};
T max()
{
return a > b ? a : b;
}
T min()
{
return a > b ? b : a;
}
private:
T a;
T b;
};
//类模板特化
template<>
class comparator<const char* >{
public:
comparator(const char *str1, const char *str2):str1(str1),str2(str2){};
const char *max()
{
return strcmp(str1, str2) > 0 ? str1 : str2;
}
private:
const char *str1;
const char *str2;
};
int main()
{
const char *str1 = "abc";
const char *str2 = "efg";
cout<<"int max:"<<mymax<int>(99, 100)<<endl;
cout<<"float max:"<<mymax<float>(0.000001, 0.000002)<<endl;
cout<<"const char *:"<<mymax<const char *>(str1, str2)<<endl;
comparator<int> c1(100, 200);
cout<<"class int max:"<<c1.max()<<endl;
cout<<"class int min:"<<c1.min()<<endl;
comparator<float> c2(0.001, 0.002);
cout<<"class float max :"<<c2.max()<<endl;
cout<<"class float min :"<<c2.min()<<endl;
comparator<const char *> c3("abc", "efg");
cout<<"class const char * max:"<<c3.max()<<endl;
return 0;
}
输出结果：
类模板的成员特化
对于类模板而言，既可以进行全类特化，也可以只针对部分与类型相关的成员函数进行特化。成员特化时要保证接口的规则和原通用模板完全一致，语法如下：
template<>
返回值类型 类模板名<特化类型...>::成员函数名(形参列表)
{
........//使用特化的类型
}
实验程序:排序
#include <iostream>
#include <cstring>
#include <string>
using namespace std;
template<typename T>
class sortor{
public:
sortor(T *a, int n)
{
this->a = new T[n];
this->n = n;
for(int i = 0; i < n; i++)
{
this->a[i] = a[i];
}
}
~sortor()
{
delete[] this->a;
}
void sort()
{
int i;
int j;
for(i = 0; i < n-1; i++)
{
bool flag = true;
for(j = 0; j < n - 1 - i; j++)
{
if (a[j]>a[j+1])
{
flag = false;
T tmp = a[j];
a[j] = a[j + 1];
a[j + 1] = tmp;
}
}
//扫描一次没有交换，说明已经排好序了
if (flag)
break;
}
}
void print()
{
for(int i=0;i<n;i++)
{
cout<<a[i]<<" ";
}
cout<<endl;
}
private:
T *a; //首地址
int n; //长度
};
//成员特化
template<>
void sortor<const char *>::sort()
{
int i;
int j;
for(i = 0;i < n - 1; i++)
{
bool flag = true;
for(j = 0; j < n - 1 - i; j++)
{
if(strcmp(a[j], a[j + 1]) > 0)
{
flag = false;
const char *tmp = a[j];
a[j] = a[j + 1];
a[j + 1] = tmp;
}
}
//扫描一次没有交换，说明已经排序好了
if(flag)
break;
}
};
int main()
{
int arr[] = {5,9,6,8,4,7,1,17,2};
double d_arr[] = {5.9,6.8,4.0,7.5,3.6,8.9,2.4,9.7,1.3};
string str_arr1[] = {"ddd","ccc","bbb","eee","aaa"};
const char *str_arr2[] = {"ddd","ccc","bbb","eee","aaa"};
sortor<int> s1(arr, sizeof(arr)/sizeof(arr[0]));
s1.sort();
s1.print();
sortor<string> s2(str_arr1,sizeof(str_arr1)/sizeof(str_arr1[0]));
s2.sort();
s2.print();
sortor<const char *> s3(str_arr2, sizeof(str_arr2)/sizeof(str_arr2[0]));
s3.sort();
s3.print();
return 0;
}
输出结果：
类模板的局部特化
对于具有多个类型参数的类模板，可以只特化其中一部分类型参数，编译器优先选择特化程度最高的版本。
1.特化一部分类型参数
template<T1,T2,T3>
class xxxxx{};
//局部特化
template<T1,T2>
class xxxxx<T1,T2,int>{};
tempalte<T1>
class xxxxx<T1,char,int>{}
2.特化类型参数的特殊关系
template<T1,T2,T3>
class xxxxx{};
//局部特化
template<T1,T2>
class xxxxx<T1,T2,T2>{};
3.特化指针和数组类型
template<T1,T2,T3>
class xxxxx{};
//局部特化
template<T1,T2,T3>
class xxxxx<T1*,T2*,T3*>{};
实验程序
#include <iostream>
#include <string>
using namespace std;
//通用类模板特化
template<typename T1, typename T2, typename T3>
class trib{
public:
trib()
{
cout<<"trib<T1, T2, T3>"<<endl;
}
};
//局部特化
//1.特化某些类型参数
template<typename T1, typename T2>
class trib<T1, T2, int>{
public:
trib()
{
cout<<"trib<T1, T2, int>"<<endl;
}
};
//2.特化类型参数的关系
template<typename T1, typename T2>
class trib<T1, T2, T2>{
public:
trib()
{
cout<<"trib<T1, T2, T2>"<<endl;
}
};
//3.特化数组/指针类型
template<typename T1, typename T2, typename T3>
class trib<T1*, T2*, T3*>{
public:
trib()
{
cout<<"trib<T1*,T2*,T2*>"<<endl;
}
};
//全特化
template<>
class trib<int, char, int>{
public:
trib()
{
cout<<"Trib<int,char,int>"<<endl;
}
};
int main()
{
trib<int, double, char> t1;//通用
trib<double, char, int> t2; //局部特化
trib<double, double, int> t3; //局部特化
trib<int, double, double> t4; ////特殊关系特化
trib<int,char,int> t5; //全特化
trib<int *,double *,char *> t6; //特化数组/指针
return 0;
}
输出结果：
类模板的默认参数
1.类模板的类型参数可以有默认值，有默认值的类型参数要放到右边，如果实例化时不提供参数的类型，就使用默认值；
2.后面类型参数的默认值可以使用前面类型参数的值；
3.非类型参数也可以有默认值。
实验程序：
#include <iostream>
#include <typeinfo>
using namespace std;
//类模板的默认参数
template <typename T1=int, typename T2=char, int T3=1000>
class A{
public:
static void print_type()
{
cout<<typeid(T1).name()<<" "
<<typeid(T2).name()<<" "
<<T3<<endl;
}
};
template<typename T1, typename T2=T1>
class B{
public:
static void print_type()
{
cout<<typeid(T1).name()<<" "
<<typeid(T2).name()<<endl;
}
};
int main()
{
const int num = 10;
A<int, int, num>::print_type();
A<double, short>::print_type();
A<string>::print_type();
A<>::print_type();
B<double>::print_type();
return 0;
}
输出结果：
智能指针
将类类型传入模板，构成智能指针
实验程序：
#include <iostream>
using namespace std;
class A{
public:
A(){cout<<"A()"<<endl;}
~A(){cout<<"~A()"<<endl;}
void show()
{
cout<<"showA()"<<endl;
}
};
//模板化指针对象
template<typename T>
class myauto_ptr{
public:
myauto_ptr(T *p=NULL):pdata(p)
{
}
myauto_ptr(myauto_ptr<T> &t) //自定义类类型将调用这个构造函数
{
this->pdata = t.data;
t.pdata = NULL;
}
~myauto_ptr()
{
if(this->pdata)
{
delete this->pdata;
this->pdata = NULL;
}
}
//重载->运算符
T *operator->()
{
return this->pdata;
}
//重载*运算符
T& operator*()
{
return *this->pdata;
}
private:
//要管理的指针
T *pdata;
};
int main()
{
int *p_int = new int(10);
myauto_ptr<int> pi(p_int);
cout<<*pi<<endl;
A *p_a = new A;
myauto_ptr<A> pa(p_a);
pa->show();
(*pa).show();
return 0;
}
输入结果：
待补充：
模板的继承
模板的模板成员
模板的模板参数
