模板(一)

//给定模板类型的实参
//在调用点，模板根据给定类型，实例化一份处理该类型的模板函数
//推演
//函数模板 ---> 
//实例化(显式、隐式) ---->
//模板函数

template<typename T>
bool compare(T a, T b)
{
	return a>b;
}


compare<char>('a','c');
compare('a','c');  模板实参的推演

模板实现一般在头文件
 
 #include<typeinfo>
 cout<<typeid(T).name<<endl;
 
 显式
 template bool compare<int>(int,int)
 
 
 ·模板特化(某些类型。。)
 
 compare("sd","sssa");
 //char*特例化版本
 template<>
 bool compare<char*>(char *a,char *b)
 {
	 return strcmp(a,b)>0?true:false;
 }
 
 
 const 右边没有指针
 
 compare<int>(10,20);
 compare<const int>(10,20);
 
 
三者可重载（共存）：
	非模板函数
	函数模板
	模板的特例化

compare<int>(10,20);
优先调用非模板函数
提供了特例化则优先调用特例化版本

template<typename T>
bool compare(const T a, const T b)
{
	return a>b;
}

//char*特例化版本
template<>
bool compare<char*>( char* const a, char* const b)	//(const char *a,const char *b)const 修饰*a
{
	return strcmp(a,b)>?true:false;	
}
 
 const T a;
 #define T char*     
 const char* a;
 typedef  char* T
 char* const a;
 
 template<typename T,int SIZE>  //SIZE模板非类型参数 (不能被修改)
 void sort(T arry[])
 {
	 for(int i=0;i<SIZE-1;++i)
	 {
		 for(int j=0;j<SIZE-1-i;++j)
		 {
			 if(arry[j]>arr[j+1])
			 {
				 T tmp = arry[j];
				 arr[j]= arry[j+1];
				 arryj[j+1]=tmp;
			 }				 
		 }
	 }
 }
 
 const a=10;//真正常量
 sort<int,a>(arry);
 
 
 模板非类型参数
 常量
 给定的模板非类型参数对应的实参也必须为常量
 任何类型的指针引用可以作为模板非类型参数
 
 
 template<typename T>
 int findValueIndex(T array[],int size,const T& val)
 {
	 for(int i=0;i<size;++i)
	 {
		 if(array[i]==val)
			 return i;
	 }
	 return -1;
 }
  
 template<>
 int findValueIndex<cahr*>(char* array[],int size,char* const &val)
 {
	 for(int i=0;i<size;++i)
	 {
		 if(strcmp(array[i],val)==0)
			 return i;
	 }
	 return -1;
 }
 
 
 类模板链表
 #include <iostream>
using namespace std;

template<typename T>//类前置声明
class CLink;

template<typename T>
class Node
{
public:
	Node(T data = T()):mdata(data),mpnext(NULL) {}	//Node<T>();  T()零初始化
	~Node() {}	//~Node<T>();
private:
	T mdata;
	Node<T> *mpnext;

	//template<typename F> //定义友
	//friend class CLink;
	friend class CLink<T>;
};

template<typename T>
class CLink
{
public:
	CLink();
	~CLink();
	void InsertTail(const T &val);
	void Show();
private:
	Node<T> *mphead;
};

template<typename T>
CLink<T>::CLink()
{
	mphead = new Node<T>();
}
template<typename T>
CLink<T>::~CLink()
{

}



template<typename T>
void CLink<T>::InsertTail(const T &val)
{
	Node<T> *p = mphead;
	while (p->mpnext != NULL)
	{
		p = p->mpnext;
	}
	Node<T> *tmp = new Node<T>(val);
	tmp->mpnext = p->mpnext;
	p->mpnext = tmp;
}

template<typename T>
void CLink<T>::Show()
{
	Node<T> *p = mphead->mpnext;
	while (p != NULL)
	{
		cout << p->mdata <<" ";
		p = p->mpnext;
	}
	cout << endl;
}

int main()
{
	CLink<int> link;
	link.InsertTail(10);
	link.InsertTail(20);
	link.InsertTail(30);
	link.Show();
}

 
 
 //类模板选择实例化



2.嵌套型

3.
//两个参数列表
template<typename T>
template<typename E>
CLink<T>::Node<E>::Node(E data = E())
{
	
} 
 特例化前需要原模板
 
 
 template<typename T>
 typename CLink<T>::Node* CLink<T>::GetNodePtr(const T& val)   //typename CLink<T>::??
 {
	 Node* p = mphead->mpnext;		//CLink<T>:: ??
	 while(p != NULL)
	 {
		 if(p->mdata == val)
		 {
			 return p;
		 }
		 p= p->mpnext;
	 }
	 return NULL;
 }