自定义模板

规则：不管是函数末班还是类模板，在证明或定义时，只能在全局命名空间或类范围内进行，不能在局部范围内，不能在函数内（包括main函数）声明或定义一个模板。

模板定义完成后，使用时需要进行实例化操作，编译器在编译时会确认模板参数具体时间哪种类型的，这个过程称为模板的实力化

函数模板的标准定义如下：

template<typename 形参名1，typename形参名2，...>
返回类型 函数名
{
    函数体
}

以下3个函数可以用一个函数模板来实现

char max(const char &a,const char &b,const char &c)
{
	char temp=(a>b)?a:b;
	return (temp>c)?temp:c;	
} 
int max(const int &a,const int &b,const int &c)
{
	char temp=(a>b)?a:b;
	return (temp>c)?temp:c;	
} 
double max(const double &a,const double &b,const double &c)
{
	char temp=(a>b)?a:b;
	return (temp>c)?temp:c;	
} 

3个重载函数的算法逻辑完全相同，只不过是输入输出的数据类型不同而已，代码的冗余度比较高

函数模板

template<typename T>

T max(const T&a,const T &b,const T &c)
{
	char temp=(a>b)?a:b;
	return (temp>c)?temp:c;	
} 

函数模板实力化

int main()
{
	int a=10;
	int b=22;
	int c=15;
	cout<<max('a','b','c')<<endl;
	cout<<max(a,b,c)<<endl;
	cout<<max(55.55,66.66,33.33)<<endl;
	return 0;
}

还有其他的一些函数模板

template<typename T> void 函数名(T a[],int n,bool type)
{
	函数体; 
}

类模板

template<typename 形参名1,typename 形参名2,...>
返回类型 类名<形参名1 ，形参名2,...>::成员函数名(形参列表)
{
	//
 } ;

类模板的实现如下

template<typename T,unsigned int N>
class Stack
{
	private:
		unsigned int index;
		T a[N];
	public:
		Stack();index(){}
		bool push(const T&valude);
		bool pop(T &value);
		bool full(){return index==N;}
		bool empty(){return index==0;}
		unsigned int size(){return index;}
		unsigned canacity(){return N;}
 } ;

template<typename T,unsigned int N> bool Stack<T,N>::push(const T&value)
{
	if((index<N-1)&&(index>=0))
	{
		a[index++]=value;
		retur true;
	}
	else
	{
		return false;
	}
}
template<typename T,unsigned int N> bool Stack<T,N>::pop(T&value)
{
	if(index==0)
	{
		
		retur false;
	}
	else
	{
		value=a[--index];
		return false;
	}
}
实例化

Stack<int ,20>a;//将Stack类模板实例化为占空间深度为20，站操作数类型为int 的类，然后在实例化对象a

Stack<char,12>ch;

Stack<float,8>f;

Stack<string,10>s;