C++模板功能学习

本文内容摘录自：从零开始学C++程序设计，仅作为入门使用
函数模板
函数模板把具有相同程序代码的函数集中写成一个函数，并且把各个函数不同数据类型的部分改以模板形式参数来替代，即可通过传递不同的数据类型的参数来创建实例函数。函数模板的声明格式与说明如下：

template <class 模板形式参数1， class 模板形式参数2，…>
返回数据类型 函数名称（参数1， 参数2， …）
{
//函数内的语句块
}

关键字class在这里并不是用来定义类的意思，而是用来声明模板形式参数。

#include <iostream>
#include <cstdlib>
using namespace std;
template <class T> //定义与声明func模板函数
T func(T n) {
	T result; //声明result为T类型变量
	result = n * n + 3 * n + 5;
	return result; 
}
int main()
{
	cout<<"func(10) = ";
	cout<<func(10)<<endl;
	cout<<"func(12.5f)=";
	cout<<func(12.5f)<<endl;
	return 0;
}

非类型参数模板
“非类型参数”表示在模板函数的参数行中含有基本数据类型，如int、float等，定义如下：

template <class模板参数1，基本数据类型 模板参数2，…>
函数类型 函数名称（函数参数）
{
//程序语句
}

#include <iostream>
#include <cstdlib>
using namespace std;
template <class arrayType, int array_size>
void showArray(arrayType (&array)[array_size])
{
	int i;
	cout<<"template非类型参数："<<endl;
	cout<<"array_size="<<array_size<<endl<<endl;
	for(i=0; i<array_size; i++) {
		cout<<"array["<<i<<"]="<<array[i]<<endl;
	} 
	cout<<endl;
}
int main()
{
	int a[]={20, 23, 56, 77, 88};
	showArray(a);
	return 0;
}

类模板
在设计类时，将数据类型以模板参数取代，在使用时再指定数据类型，这种类就称为类模板。
类模板的声明格式如下：

template <class 模板形式参数1， class模板形式参数2， …>
class 类名称 {
//类内的语句区块
}

若是类成员函数定义在类外部，则必须附加类模板声明与范围解析运算符（：：），如下所示：

template <class模板形式参数>
class 类名称
{
模板参数 函数名称（）；
}
template <class模板形式参数>
函数类型 类名称<模板参数> ::函数名称（）
{
//程序语句
}

声明完类模板后，就要用类模板来产生对象，对象的产生方式如下：

类名称<数据类型> 对象名称；//声明对象
或
类名称<数据类型> 对象名称（）；//对象名称、对象和构造函数的合并声明

#include <iostream>
#include <cstdlib>
using namespace std;
template <class type>
class function
{
	private:
		type y;
	public:
		function(type x) {
			y = x;
		}
		void show()
		{
			cout<<"y="<<y<<endl;
		}
};
int main()
{
	function<int> func1(10);//对象名称、对象和构造函数的合并声明
	func1.show();
	function<float> func2(9.8);//对象名称、对象和构造函数的合并声明
	func2.show();
	function<char> func3('z');
	func3.show();
	return 0; 
}

堆栈类模板

#include <iostream>
#include <cstdlib>
using namespace std;
//设置类模板的类型参数Type的默认值为整数int，非类型参数的类型值为整数int，默认值为5 
template <class Type = int, int size = 5> //类模板声明
class Stack
{
	private:
	Type st[size];
	int top;
	public:
	Stack() {
		top = -1;
	}
	void push(Type data);
	Type pop();
};
template <class Type, int size>
void Stack <Type, size> :: push (Type data) {
	st[++top] = data;	
}
template <class Type, int size>
Type Stack<Type, size> :: pop() {
	return st[top--];
}
int main()
{
	Stack<> stk_1;//声明一个堆栈对象，并使用其默认值
	Stack<char*, 4> stk_2;
	stk_1.push(11);
	stk_1.push(22);
	stk_1.push(33);
	cout<<"stack_1 [1]=" << stk_1.pop() <<endl;
	cout<<"stack_1 [2]=" << stk_1.pop() <<endl;
	cout<<"stack_1 [3]=" << stk_1.pop() <<endl;
	cout<<endl;
	stk_2.push("第一名");
	stk_2.push("第一名");
	stk_2.push("第一名"); 
	cout<<"stack_2 [1]=" << stk_2.pop() <<endl;
	cout<<"stack_2 [2]=" << stk_2.pop() <<endl;
	cout<<"stack_2 [3]=" << stk_2.pop() <<endl;
	cout<<endl;
	return 0;
}

非类型参数类模板
在声明对象时除了指定此对象的数据类型外，通过常数值的传递还可以同时指定对象内数组元素的个数与堆栈空间。

#include <iostream>
#include <cstdlib>
using namespace std;
template <class T,int N> //声明模板形式参数T，数据类型固定参数N
class CalAdd //声明类模板CallAdd
{
	private:
		T Total;
		T Num[N];
	public:
		CalAdd() {
			Total = 0;
		}//CalAdd类的构造函数
		void InNum();
		void AddNum();
		void ShowResult(); 
};
template <class T, int N>  void CalAdd<T, N> :: InNum() //成员函数InNum()
{
	for(int count = 0; count < N; count++) {
		cout<< "输入数据：";
		cin>> Num[count]; 
	}
 } 
template <class T, int N> void CalAdd<T, N> :: AddNum()
{
	for(int count = 0; count < N; count++) {
		Total += Num[count];
	}
}
template <class T, int N> void CalAdd<T, N> :: ShowResult()
{
	AddNum();
	for(int count =0; count < N; count++) {
		cout<<Num[count];
		if(count < (N-1)) 
		cout<<"+";
	}
	cout<<" = "<< Total <<endl;
}
int main()
{
	CalAdd<int, 4> iCal;//使用类模板CalAdd声明int数据类型对象iCal
	CalAdd<double, 5> dCal;
	cout << "<计算4个int数据类型的综合>"<<endl;
	iCal.InNum();
	iCal.ShowResult();
	cout<<"<计算5个double数据类型的综合>"<<endl;
	dCal.InNum();
	dCal.ShowResult();
	return 0;
}