目录
分类
一、模板类不继承
（1）代码
（2）分析
（3）运行结果
二、模板类继承普通类
（1）代码
（2）分析
（3）运行结果
三、普通类继承模板类的实例版本
（1）代码
（2）分析
3）运行结果
四、普通类继承模板类（常见）（模板类含通用类型参数）
（1）代码
（2）分析
（3）运行结果
五、模板类继承模板类
（1）代码
（2）分析
（3）运行结果
六、模板类继承模板参数给出的基类（不能是模板类）
（1）代码
（2）分析
（3）运行结果
分类
1）模板类继承普通类（常见）
2）普通类继承模板类的实例版本
3）普通类继承模板类（常见）
4）模板类继承模板类
5）模板类继承模板参数给出的基类（不能是模板类）
一、模板类不继承
（1）代码
#include<iostream>
using namespace std;
//模板类BB
template<class T1,class T2>
class BB
{
public:
T1 m_x;
T2 m_y;
BB(const T1 x,const T2 y):m_x(x),m_y(y){cout<<"调用了BB的构造函数。"<<endl;}
void fun2()const{cout<<"调用了func2()函数：x="<<m_x<<",y="<<m_y<<endl;}
};
int main()
{
BB<int,string>bb(8,"我是一只小猫咪。");
bb.fun2();
return 0;
}
（2）分析
①模板类BB直接实例化，不继承其他类。
（3）运行结果
二、模板类继承普通类
（1）代码
//普通类AA作为基类，BB类作为派生类
#include<iostream>
using namespace std;
//AABB都没有默认的构造函数
//普通类AA
class AA
{
public:
int m_a;
AA(int a):m_a(a){cout<<"调用了AA的构造函数。"<<endl;}
void fun1(){cout<<"调用了func1（）函数：m_a="<<m_a<<endl;}
};
//模板类BB
template<class T1,class T2>
class BB:public AA //111111继承普通类
{
public:
T1 m_x;
T2 m_y;
BB(const T1 x,const T2 y,int a):AA(a),m_x(x),m_y(y){cout<<"调用了BB的构造函数。"<<endl;} //222222派生类的构造函数要调用基类的构造函数
void fun2()const{cout<<"调用了func2()函数：x="<<m_x<<",y="<<m_y<<endl;}
};
int main()
{
BB<int,string>bb(8,"我是一只小猫咪。",3);
bb.fun2();
bb.fun1(); //调用基类的func1（）函数
return 0;
}
（2）分析
①程序定义了一个普通类AA，模板类BB作为基类继承普通类AA
template<class T1,class T2> //加模板标签
class BB:public AA
②只需要修改派生类BB的构造函数，调用基类AA的构造函数即可；
BB(const T1 x,const T2 y,int a):AA(a),m_x(x),m_y(y)
（3）运行结果
三、普通类继承模板类的实例版本
（1）代码
#include<iostream>
using namespace std;
//AABB都没有默认的构造函数
//模板类BB
template<class T1,class T2>
class BB
{
public:
T1 m_x;
T2 m_y;
BB(const T1 x,const T2 y):m_x(x),m_y(y){cout<<"调用了BB的构造函数。"<<endl;}
void fun2()const{cout<<"调用了func2()函数：x="<<m_x<<",y="<<m_y<<endl;}
};
//普通类AA
class AA:public BB<int,string> //普通类AA继承模板类BB
{
public:
int m_a;
AA(int a,int x,string y):BB(x,y),m_a(a){cout<<"调用了AA的构造函数。"<<endl;} //派生类构造函数调用基类构造函数（初始化列表）
void fun1(){cout<<"调用了func1（）函数：m_a="<<m_a<<endl;}
};
int main()
{
AA aa(3,8,"我是一只小猫咪。");
aa.fun1(); //调用派生类函数
aa.fun2(); //调用基类函数
return 0;
}
（2）分析
①普通类AA作为派生类继承模板类BB
AA只是继承BB的某一个实例化版本，普通类继承，没有特殊之处
class AA:public BB<int,string> //不需要加模板标签
②修改派生类AA的构造函数调用基类BB的构造函数即可
AA(int a,int x,string y):BB(x,y),m_a(a)
3）运行结果
四、普通类继承模板类（常见）（模板类含通用类型参数）
（1）代码
#include<iostream>
using namespace std;
//AABB都没有默认的构造函数
//模板类BB
template<class T1,class T2>
class BB
{
public:
T1 m_x;
T2 m_y;
BB(const T1 x,const T2 y):m_x(x),m_y(y){cout<<"调用了BB的构造函数。"<<endl;}
void fun2()const{cout<<"调用了func2()函数：x="<<m_x<<",y="<<m_y<<endl;}
};
//模板类AA
template<class T1,class T2> //11111BB的模板类标签复制下来
class AA:public BB<T1,T2> //22222普通类继承通用模板类
{
public:
int m_a;
AA(int a,T1 x,T2 y):BB<T1,T2>(x,y),m_a(a){cout<<"调用了AA的构造函数。"<<endl;} //333333修改构造函数
void fun1(){cout<<"调用了func1（）函数：m_a="<<m_a<<endl;}
};
int main()
{
AA <int,string>aa(3,8,"我是一只小猫咪。"); //4444AA是一个模板类，需要模板标签
aa.fun1();
aa.fun2();
return 0;
}
（2）分析
①普通类AA作为派生类继承模板类BB（非实例化）
要保留BB的通用类型，就需要把AA变成模板类
template<class T1,class T2> //BB的模板类标签复制下来
class AA:public BB<T1,T2> //普通类继承通用模板类
②修改派生类AA的构造函数调用基类BB的构造函数即可
AA(int a,T1 x,T2 y):BB<T1,T2>(x,y),m_a(a)
（3）运行结果
五、模板类继承模板类
（1）代码
#include<iostream>
using namespace std;
//AABB都没有默认的构造函数
//模板类BB
template<class T1,class T2>
class BB
{
public:
T1 m_x;
T2 m_y;
BB(const T1 x,const T2 y):m_x(x),m_y(y){cout<<"调用了BB的构造函数。"<<endl;}
void fun2()const{cout<<"调用了func2()函数：x="<<m_x<<",y="<<m_y<<endl;}
};
//普通类AA
template<class T1,class T2>
class AA:public BB<T1,T2>
{
public:
int m_a;
AA(int a,T1 x,T2 y):BB<T1,T2>(x,y),m_a(a){cout<<"调用了AA的构造函数。"<<endl;}
void fun1(){cout<<"调用了func1（）函数：m_a="<<m_a<<endl;}
};
//模板类CC
template<class T,class T1,class T2> //11111111CC类模板标签增加两个通用类型参数
class CC:public BB<T1,T2> //22222222CC类继承BB类
{
public:
T m_a;
CC(const T a,const T1 x,const T2 y):BB<T1,T2>(x,y),m_a(a){cout<<"调用了CC的构造函数。\n"<<endl;} //CC类构造函数调用基类BB构造函数
void fun3(){cout<<"调用了fun3（）函数：m_a="<<m_a<<endl;}
};
int main()
{
CC <int,int,string>cc(3,8,"我是一只小猫咪。");
cc.fun3();
cc.fun2();
return 0;
}
（2）分析
①增加一个模板类CC
template<class T>
class CC
{
public:
T m_a;
CC(const T a):m_a(a){cout<<"调用了CC的构造函数。\n"<<endl;}
void fun3(){cout<<"调用了fun3（）函数：m_a="<<m_a<<endl;}
};
②模板类CC继承BB
template<class T,class T1,class T2> //CC类模板标签增加两个通用类型参数
class CC:public BB<T1,T2> //CC类继承BB类
②修改派生类CC的构造函数调用基类BB的构造函数即可；
CC(const T a,const T1 x,const T2 y):BB<T1,T2>(x,y),m_a(a)
（3）运行结果
六、模板类继承模板参数给出的基类（不能是模板类）
（1）代码
#include<iostream>
using namespace std;
//普通类AA
class AA
{
public:
AA(){cout<<"调用了AA的构造函数AA()。"<<endl;}
AA(int a){cout<<"调用了AA的构造函数AA(int a)。"<<endl;}
};
//普通类BB
class BB
{
public:
BB(){cout<<"调用了BB的构造函数BB()。"<<endl;}
BB(int a){cout<<"调用了BB的构造函数BB(int a)。"<<endl;}
};
//普通类CC
class CC
{
public:
CC(){cout<<"调用了CC的构造函数CC()。"<<endl;}
CC(int a){cout<<"调用了CC的构造函数CC(int a)。"<<endl;}
};
//模板类DD
template<class T>
class DD
{
public:
DD(){cout<<"调用了DD的构造函数DD()。"<<endl;}
DD(int a){cout<<"调用了DD的构造函数DD(int a)。"<<endl;}
};
//模板类EE
template<class T>
class EE:public T
{
public:
EE():T(){cout<<"调用了EE的构造函数EE()。"<<endl;}
EE(int a):T(a){cout<<"调用了EE的构造函数EE(int a)。"<<endl;}
};
int main()
{
EE<AA>ea1;//AA作为基类
EE<BB>eb1;//BB作为基类
EE<CC>ec1;//CC作为基类
EE<DD<int> >ed1; //DD<int>作为基类,模板类作为基类时，必须明确指出模板类型参数
//EE<DD>ed1; //DD作为基类，错误
return 0;
}
（2）分析
①EE是模板类，有一个通用模板类型参数，在继承时T可以是普通类，也可以是模板类；
②但是在继承模板类的时候需要指明基类的通用类型参数。
EE<DD<int> >ed1; //DD<int>（类名）作为基类,模板类作为基类时，必须明确指出模板类型参数
//EE<DD>ed1; //DD作为基类，错误
（3）运行结果
