总结:
1) 先写出一个实际的类。 由于其语义明确, 含义清楚, 一般不会出错。2) 将此类中准备改变的类型名(如 int 要改变为 float 或 char)改用一个自己指定的虚拟类型名(如上例中的 numtype)。3) 在类声明前面加入一行, 格式为:template <class 虚拟类型参数>如:template <class numtype> //注意本行末尾无分号class Compare{…}; //类体4) 用类模板定义对象时用以下形式:类模板名类模板名<实际类型名> 对象名;类模板名<实际类型名> 对象名(实参表列);如:Compare<int> cmp;Compare<int> cmp(3,7);5) 如果在类模板外定义成员函数, 应写成类模板形式:template <class 虚拟类型参数>函数类型 类模板名<虚拟类型参数>::成员函数名(函数形参表列) {…}关于类模板的几点说明:1) 类模板的类型参数可以有一个或多个, 每个类型前面都必须加 class, 如:template <class T1,class T2>class someclass {…};在定义对象时分别代入实际的类型名, 如:someclass<int,double> obj;2) 和使用类一样, 使用类模板时要注意其作用域, 只能在其有效作用域内用它定义对象。3) 模板可以有层次, 一个类模板可以作为基类, 派生出派生模板类。
#include<iostream>
using namespace std;
template <class numtype>//声明
class Compare
{public:
Compare(numtype a, numtype b);
numtype max();
numtype min();
private:
numtype x;
numtype y;
};
template<class numtype>
Compare<numtype>::Compare(numtype a, numtype b)//类外定义时需要先声明,需要在域运算符前加上<numtype>
{
x = a;
y = b;
}
template<class numtype>
numtype Compare<numtype>::max()
{
if (x > y)
return x;
else
return y;
}
template<class numtype>
numtype Compare<numtype>::min()
{
if (x< y) ? x : y;
}
int main()
{
Compare<int>c1(1, 2);//类模板的调用
cout << c1.max() << endl;
system("pause ");
return 0;
}
//类模板派生普通类:
#include<iostream>
using namespace std;
template<class T>
class A1
{
public:
A1(T a)
{
this->a = a;
}
int get()
{
return a;
}
private:
T a;
};
class B:public A1<int>//从模板类派生时,需要知道父类所占内存空间大小
{
public:
B(int a,int b) :A1<int>(a)
{
this->b = b;
}
void printf()
{
cout << get() << " " << b << endl;
}
private:
int b;
};
int main03()
{
B b1(1,2);//
b1.printf();
system("pause");
return 0;
}
//类模板派生模板类
#include<iostream>
using namespace std;
template<class T>
class A2
{
public:
A2(T a)
{
this->a = a;
}
int get()
{
return a;
}
private:
T a;
};
template<class T>
class B1:public A2<T>
{public:
B1(T a,T b) :A2<T>(a)
{
this->b = b;
}
void print()
{
cout << get() << b << endl;
}
private:
T b;
};
int main()
{
B1 <int> c(23, 20);
c.print();
system("pause");
return 0;
}
#include<iostream>
using namespace std;
template<typename T>
class Complex
{
public:
Complex(T real, T imag);
/*{
this->real = real;
this->imag = imag;
}*/
public:
void print();
Complex operator+(Complex &c1);
Complex operator-(Complex &c1);
friend ostream& operator<< <T>(ostream&out, Complex &c3);//注意写法
//void print()//函数体写在类的内部,没有问题
/*{
cout << "real:" << real << "imag:" << imag << endl;
}*/
//Complex operator+(Complex &c1)//函数体写在类的内部,没有问题
/*{
Complex tem(real + c1.real, imag + c1.imag)
return tem;
}*/
//friend ostream& operator<<(ostream&out, Complex &c3)//函数体写在类的内部,没有问题
/*{
out << c3.real << "+" << c3.imag << "i" << endl;
return out;
}*/
private:
T real;
T imag;
};
//构造函数写在类的外部
template<typename T>
Complex<T> ::Complex(T real, T imag)
{
this->real = real;
this->imag = imag;
}
//成员函数写在类的外部
template<typename T>
void Complex<T>::print()
{
cout << "real:" << real << "imag:" << imag << endl;
}
//运算符重载写在类的外部
//模板类需要具体化,分配内存,注意写法
template<typename T>
Complex<T> Complex<T>::operator+(Complex<T> &c1)
{
Complex tem(real + c1.real, imag + c1.imag);
return tem;
}
template<typename T>
Complex<T> Complex<T>::operator-(Complex<T> &c1)
{
Complex temp(real - c1.real, imag - c1.imag);
return temp;
}
//友元函数写在类的外部
//本质:模板是两次编译,第一次生成的函数头与第二次函数头不同
//错误 1 error LNK2019: 无法解析的外部符号 "class std::basic_ostream<char,struct std::char_traits<char> > &
//__cdecl operator<<
//(class std::basic_ostream<char,struct std::char_traits<char> > &,class Complex<int> &)"
//(??6@YAAAV?$basic_ostream@DU?$char_traits@D@std@@@std@@AAV01@AAV?$Complex@H@@@Z),
//该符号在函数 _main 中被引用 C:\Users\HSY\Desktop\函数模板001\函数模板001\复数类的模板类.obj 函数模板001
template<typename T>
ostream& operator<<(ostream&out, Complex<T> &c3)
{ if (c3.imag>0)
out << c3.real << "+" << c3.imag << "i" << endl;
else
out << c3.real << c3.imag << "i" << endl;
return out;
}
int main()
{
//模板类需要具体化,分配内存,注意写法
Complex<int> c1(1,2);
Complex<int> c2(3, 4);
Complex<int> c3 = c1 + c2;
Complex<int> c4 = c1 - c2;
cout << c3;
cout << endl;
cout << c4;
cout << endl;
system("pause");
return 0;
}