类模板

“我相信任何事情都不会不留痕迹就过去，对现在的和将来的生活来说，我们所走的最小的一步路都是有意义的。”————契诃夫

同函数模板一样，使用类模板可以为类定义一种模式，使得类中的某些数据成员、某些成员函数的参数以及某些成员函数的返回值能取任意类型。

定义

类是对一组对象的公共性质的抽象
类模板是对不同类的公共性质的抽象。（一种更高层次的抽象）
格式：

template<模板参数表>
class<类模板名>
{
<类成员声明>
}

类模板中的成员函数和重载的运算符必须为函数模板。

类模板的实例化

//通用数组类
#include<iostream>
using namespace std;
const int size=10;
template<typename AType>class atype//类模板
{
	public:
		atype()
		{
			int i;
			for(i=0;i<size;i++)
				array[i]=i;
		}
		AType &operator[](int n);
	private:
		AType array[size];
 };
 //类外定义的格式 
 //template<模式参数表>
 //<返回值类型><类模板名><类型名表>::<函数名>(<参数表>)
 template<typename AType>
 AType &atype<AType>::operator[](int n)
 {
 	//下标越界检查
	 if(n<0||n>=size)
	 {
	 	cout<<"下标"<<n<<"超出范围！"<<endl;
		 exit(1); 
	  } 
	  return array[n];
 }
 int main()
 {
 	atype<int>intob;
 	atype<double>doubleob;
 	int i;
 	cout<<"Integer数组";
 	for(i=0;i<size;i++) intob[i]=i;
 	for(i=0;i<size;i++)
 		cout<<intob[i]<<" ";
 	cout<<endl;
 	cout<<"Double 数组";
 	for(i=0;i<size;i++)
 		cout<<doubleob[i]<<" ";
 	cout<<endl;
 	intob[12]=100;//示范一下如果下标越界会出现什么结果 
 	return 0;
 }

结果：

Integer数组0 1 2 3 4 5 6 7 8 9
Double 数组0 1 2 3 4 5 6 7 8 9
下标12超出范围！

使用函数类型参数的类模板

在类模板的<模板参数表>中，必须至少有一个类参数，当然也可以有多个类参数。还可以有非类参数的参数，这样的参数一般被称为函数类型参数（也可以称为无类型模板参数）
函数类型参数只限于整型、指针型、引用，其他类型不能使用。

下面的程序为数组类模板提供了更好的方法，它使程序员能够指定数组的大小。

//使用函数类型参数的类模板 
#include<iostream>
using namespace std;
template<typename AType,int size>
class atype//模板类 
{
	public:
		atype()
		{
			int i;
			for(i=0;i<size;i++)
				array[i]=i;
		}
		AType &operator[](int n);
	private:
		AType array[size];
 };
 //类外定义的格式 
 //template<模式参数表>
 //<返回值类型><类模板名><类型名表>::<函数名>(<参数表>)
 template<typename AType,int size>
 AType &atype<AType,size>::operator[](int n)
 {
 	//下标越界检查
	 if(n<0||n>=size)
	 {
	 	cout<<"下标"<<n<<"超出范围！"<<endl;
		 exit(1); 
	  } 
	  return array[n];
 }
 int main()
 {
 	//10个元素的integer数组类，intob为该类的一个对象 
 	atype<int,10>intob;
 	//10个元素的double数组类，doubleob为该类的一个对象 
 	atype<double,10>doubleob;
 	int i;
 	cout<<"Integer数组";
 	for(i=0;i<10;i++) intob[i]=i;
 	for(i=0;i<10;i++)
 		cout<<intob[i]<<" ";
 	cout<<endl;
 	cout<<"Double 数组";
 	for(i=0;i<10;i++)
 		cout<<doubleob[i]<<" ";
 	cout<<endl;
 	return 0;
 }

结果：

Integer数组0 1 2 3 4 5 6 7 8 9
Double 数组0 1 2 3 4 5 6 7 8 9

使用默认参数的类模板

类模板可以包含与通用类型相关的默认参数，当类模板被实例化时，如果没有制定其他的数据类型，则使用默认类型。
函数类型参数也可以使用默认参数。

//使用默认参数的类模板 
#include<iostream>
using namespace std;
template<typename AType=int,int size=10>//变化在这里！！有默认参数了 
class atype
{
	public:
		atype()
		{
			int i;
			for(i=0;i<size;i++)
				array[i]=i;
		}
		AType &operator[](int n);
	private:
		AType array[size];
 };

举例实现：

	//12个元素的integer数组类，intob为该类的一个对象 
 	atype<int,12>intob;
 	//double数组类，数组大小为默认值10，doubleob为该类的一个对象 
 	atype<double>doubleob;
 	//数组类，类型为默认值int，数组大小默认为10，defaultob为该类的一个对象
	 atype<>defaultob; 

完整代码如下：

//使用默认参数的类模板 
#include<iostream>
using namespace std;
template<typename AType=int,int size=10>//变化在这里！！有默认参数了 
class atype
{
	public:
		atype()
		{
			int i;
			for(i=0;i<size;i++)
				array[i]=i;
		}
		AType &operator[](int n);
	private:
		AType array[size];
 };
 //类外定义的格式 
 //template<模式参数表>
 //<返回值类型><类模板名><类型名表>::<函数名>(<参数表>)
 template<typename AType,int size>
 AType &atype<AType,size>::operator[](int n)
 {
 	//下标越界检查
	 if(n<0||n>=size)
	 {
	 	cout<<"下标"<<n<<"超出范围！"<<endl;
		 exit(1); 
	  } 
	  return array[n];
 }
 int main()
 {
 	//12个元素的integer数组类，intob为该类的一个对象 
 	atype<int,12>intob;
 	//double数组类，数组大小为默认值10，doubleob为该类的一个对象 
 	atype<double>doubleob;
 	//数组类，类型为默认值int，数组大小默认为10，defaultob为该类的一个对象
	 atype<>defaultob; 
 	int i;
 	cout<<"Integer数组";
 	for(i=0;i<12;i++) intob[i]=i;
 	for(i=0;i<12;i++)
 		cout<<intob[i]<<" ";
 	cout<<endl;
 	cout<<"Double 数组";
 	for(i=0;i<10;i++)
 		doubleob[i]=(double)i/2;
 	for(i=0;i<10;i++)
 		cout<<doubleob[i]<<" ";
 	cout<<endl;
 	cout<<"默认参数数组：";
 	for(i=0;i<10;i++)
 		cout<<defaultob[i]<<" ";
 	cout<<endl;
 	return 0;
 }

结果：

Integer数组0 1 2 3 4 5 6 7 8 9 10 11
Double 数组0 0.5 1 1.5 2 2.5 3 3.5 4 4.5
默认参数数组：0 1 2 3 4 5 6 7 8 9

终于弄清楚基础了，下面可以学stl了