类模板(泛型编程)
泛型编程：（方法一致，但数据类型不确定）由函数模板或者类模板来完成的。
函数模板
template
函数定义;
类模板：定义相同的操作，拥有不同数据类型的成员属性。
template
class 类名
{
//属性
确定类型
泛型
};
类模板继承
template
class parent
{
};
//注意：
1、如果子类不是类模板，则父类必须声明类模板的数据类型
2、子类必须初始化父类（父类的构造器）
3、如果子类模板，要么指定父类的类型，要么用子类的泛型来指定父类。
在子类中初始化父类部分时，由构造器来构造器。调用构造器需要指定类型。
clas child:<继承方式> parent<类型>
{
...
child():parent<类型>(..)
...
};
1、类模板实例化
类<类型> 对象;
2、类外定义函数：
template
类名
{
}
3、二次编译:见代码Complex.cpp代码（重载输出运算符）
解决：前置声明。先在类定义的上面声明该函数为模板函数。
1、类的前置声明（类模板）
template
class 类名;
2、友元函数(模板函数)的前置声明
template
函数声明;
3、声明友元函数时，增加泛型支持。
friend ostream& operator<<
类模板的使用 .
#include
#include
using namespace std;
class people
{
public:
//无参构造
people(){}
people(const char* n,char s):name(n),sex(s)
{
}
friend ostream& operator<<(ostream&,people&);
protected:
string name;//姓名
char sex;
};
//重载运算符--友元函数
ostream& operator<<(ostream& output,people& p)
{
output<
class Array
{
public:
//构造器
Array(T b[],int ilen)//局部变量优先
{
this->ilen=ilen;
memcpy(this->buf,b,ilen*sizeof(T));//内存拷贝
}
void show()
{
int i=0;
while(iilen)
{
//基本类型，如果是复杂类型则重载
cout<buf[i++]<<" ";
}
cout< a(buf,5);
a.show();
//浮点型
float buf1[10]={3.14,7.0,8.9};
Array b(buf1,3);
b.show();
//复杂类型
people buf2[3]={people("lifei,",'m'),people("lj",'m'),people("zzs",'w')};
Array c(buf2,3); //Array（people* ,int）
//构造器
c.show();
} 在复杂类型的时候 T buf[100]; 的时候 , 因为此时的 T 是复杂类型 相当于==> people buf[100] ; 所以此时的 T buf[100] ; 会调用到 people 的无参构造 , 所以切记要为people 添加一个无参构造 , 在输出show的时候 , 因为是复杂类型 ,所以需要对输出运算符进行重载输出 , 不然会输出报错!
子类继承父类模板的使用 :
子类继承父类的模板类 , 子类需要为继承的父类添加类型 , 可以自己定义类型 , 也可以定义子类的泛型 .
#include
#include
using namespace std;
//类模板：
template
class people
{
public:
//有参构造：如果有参被定义，则无参构造不会被生成
people(){}
people(T i):id(i){}
protected:
T id;
};
//子类：是类型模板
template
class worker:public people//people要么自己指定类型，要么用子类的泛型
{
public:
//无参
worker():people()
{
}
worker(T1 id,T1 g,int s):people(id)
{
this->g=g;
this->score=s;
}
void show()
{
cout<
{
public:
//
worker():people()
{
}
worker(int i,const char* n):people(i),name(n)
{
}
void show()
{
cout<<"ID:"<id<<" "<name< a;
worker w(1001,"llllllll");
w.show();
*/
worker w(1001,4,100);
w.show();
return 0;
}
类外实现方法的定义 :
#include
using namespace std;
//前置声明：告诉编译器此函数为模板函数
template
class Complex;//声明类
template
ostream& operator<<(ostream&,Complex &);
//类模板
template
class Complex
{
public:
Complex(T d1,T d2);
//友元
friend ostream& operator<<(ostream&,Complex &);
protected:
T a;
T b;
};
//类外实现方法的定义
template
Complex::Complex(T d1,T d2):a(d1),b(d2)
{
}
//重载输出 Complex是泛型 函数模板
template
ostream& operator<<(ostream& output,Complex &c)
{
output< c(1,2);
cout<