C++ 类模板、模板类、定义标准输入\输出

1. 模板思想实现与类型无关,只与功能实现有关.
   类模板:定义类时数据类型不定
   模板类:使用类实例化对象,指定类型.构建一个具体对象

#include  <iostream>
#include  <stdio.h>
#include  <string.h>
using namespace std;
class Student
{
	friend istream& operator >>(istream &in,Student &s);//因为访问了私有成员，所以这里做友元函数处理
	friend ostream& operator <<(ostream &out,Student &s);//因为访问了私有成员，所以这里做友元函数处理
public:
	Student()
	{

	}
	Student(int _id,const char * _name)
	{
		id=_id;
		strcpy(name,_name);
	}

	bool operator >(Student s) //重载 > 符号
	{
		return (this->id > s.id);
	}
private:
	int id;
	char name[10];
};
//定义标准输入 返回和第一个参数必须是引用
istream& operator >>(istream &in,Student &s)
{
	in>>s.id>>s.name;
	return in;
}
//定义标准输出 返回和第一个参数必须是引用
ostream& operator <<(ostream &out,Student &s)
{
	out<<s.id<<"  "<<s.name<<endl;
	return out;
}

//自定义数组类模板
template<class T>//T 表示数据类型不定
class Array
{
public:
	Array(int _size)
	{
		size=_size;
		ptr = new T[size];
	}

	void inputvale()//输入数组值
	{
		int i;
		for(i=0;i<size;i++)
		{
			cin>>ptr[i];//这里不是基础类型就用到了我们自己在Student 类里面定义的标准输入

		}
	}

	void outputvalue()//输出数组值
	{
		int i;
		for(i=0;i<size;i++)
		{
			cout<<ptr[i];//这里不是基础类型就用到了我们自己在Student 类里面定义的标准输出
		}
		cout<<endl;
	}

	void sortvalue()//对数组进行排序（冒泡法）
	{
		int i,j;
		for(i=0;i<size;i++)
		{
			for(j=0;j<size-i-1;j++)
			{
				if(ptr[j]>ptr[j+1])//如果这个数组不是用来装基础类型的值，而是自定义类型的值，那么要在自定义类里面实现重载“>”的方法。
				{
					T tmp=ptr[j];
					ptr[j]=ptr[j+1];
					ptr[j+1]=tmp;
				}
			}
		}
	}
private:
	T *ptr;
	int size;//数组的大小	
};

int main(int argc, char const *argv[])
{
	Array<Student>  array(5);
	array.inputvale();
	array.sortvalue();
	cout<<"对自定义类数组排序后的结果："<<endl;
	array.outputvalue();
	return 0;
}

运行结果：

 

 

 

 

 

 

 

 

 

• 对size 的另一种写法  类模板参数变量

template<class T,int size>//类模板参数变量不能与类中变量 同名,否则隐藏类中变量
class Array
{
public:
	Array(int _size)
	{
		//size=_size;
		ptr=new T[size];
	}
	void  inputvalue();
	void  outputvalue()
	{
		int i;
		for(i=0;i<size;i++)
		{
			cout<<ptr[i]<<"\t";
		}
		cout<<endl;
	}
	void  sortvalue()
	{
		int i,j;
		for(i=0;i<size;i++)
		{
			for(j=0;j<size-i-1;j++)
			{
				if(ptr[j]>ptr[j+1])
				{
					T tmp=ptr[j];
					ptr[j]=ptr[j+1];
					ptr[j+1]=tmp;
				}
			}
		}
	}
private:
	T *ptr;
	//int size;//模板参数隐藏
};

template<class T1,int size>//只能用在最近作用域
void  Array<T1,size>::inputvalue()
{
		int i;
		for(i=0;i<size;i++)
		{
			cin>>ptr[i];
		}
}

int main(int argc, char const *argv[])
{
	Array<string,5>  a1(5);
	a1.inputvalue();
	a1.sortvalue();
	a1.outputvalue();
	return 0;
}

• 类模板参数默认值

//定义类模板
template<class T=int,int size=5>//类模板参数默认值
class Array
{
public:
	Array(int _size)
	{
		//size=_size;
		ptr=new T[size];
	}
	void  inputvalue();
	void  outputvalue()
	{
		int i;
		for(i=0;i<size;i++)
		{
			cout<<ptr[i]<<"\t";
		}
		cout<<endl;
	}
	void  sortvalue()
	{
		int i,j;
		for(i=0;i<size;i++)
		{
			for(j=0;j<size-i-1;j++)
			{
				if(ptr[j]>ptr[j+1])
				{
					T tmp=ptr[j];
					ptr[j]=ptr[j+1];
					ptr[j+1]=tmp;
				}
			}
		}
	}
private:
	T *ptr;
	//int size;//模板参数隐藏
};

template<class T1,int size>//只能用在最近作用域
void  Array<T1,size>::inputvalue()
{
		int i;
		for(i=0;i<size;i++)
		{
			cin>>ptr[i];
		}
}

int main(int argc, char const *argv[])
{
	//Array<int>  a1(5);//实例化对象 
	
	//Array<char>  a1(5);//T代表char size还是默认的

	Array<>  a1(5);//都用默认值
	a1.inputvalue();
	a1.sortvalue();
	a1.outputvalue();
	return 0;
}