模板

函数模板

//函数模板
template<typename T>
T tdmax(T a,T b){
   return a +b;
}

// T是模板参数
// a和b是调用参数

显示指定模板类型 

template<typename T>
T const& max(T const& a,T const7 b){
   return a+b;
}

max<double>(4,3.3);  //显示指定T类型是double类型

template<typename T1，typename T2>
T1 const& max(T1 const& a,T2 const& b){
   return a+b;
}

max<double>(3,2.2); //显示指定T1是double类型，T2靠编译器自己推断

类模板

 定义

template<typename T>
class Stack{
 private:
  std::vector<T> elems;
 public:
   Stack(); //构造函数
   void push(T const&); //压入元素
   void pop(); //弹出元素
   T top() const;  //返回栈顶元素  
}

template<typename T>
void Stack<T>::push(T const& elem)
{
  elems.push_back(eleme);
}

类模板特化

必须再起始处声明一个template<>

template<>
class Stack<std::string>{
 ...
}

进行类模板特化时，每个成员函数必须重新定义为普通函数，原来模板函数每个T也响应进行被特化类型取代

void Stack<std::string>::push (std::string const& elem){
     elems.push_back(elem);
}

局部特化

//两个模板参数有相同类型
template<typename T>
class MyClass<T,T>{
};

//局部特化，第2个模板参数类型是int
template<typename T>
class Myclass<T,int>{
...
};

//局部特化，两个模板参数都是指针
template<typename T1,typename T2>
class MyClass<T1*,T2*>{
};

缺省模板参数

template <typename T,typename CONT= std::vector<T> >
class Stack {
private:
	CONT elems;
public:
	void push(T const&);
};

template<typename T,typename CONT>
void Stack<T, CONT>::push(T const& elem) {
	elems.push_back(elem);
}

int main()
{
	Stack<int> intStack;                         //默认使用vector来管理元素
	Stack<double, std::deque<double> > dbStack;  //使用deque来管理元素
	
	return 0;
}

非类型类模板参数

普通得值当作模板参数，就是非类型模板参数，不是int，不是double 而是具体得值

template <typename T, int MAXSIZE>
class Stack {
private:
	T elems[MAXSIZE];
	int numElems;
public:
	void push(T const&);

};

template<typename T,int MAXSIZE>
void Stack<T,MAXSIZE>::push(T const& elem) {
	elems[numElems] = elem;
	numElems++
}

int main()
{
	Stack<int,20> intStack;
	return 0;
}

模板参数指定缺省值

template<typename T = int, int MAXSIZE = 100>
class Stack {
};

非类型函数模板参数

template<typename T, int VAL>
T addValue(T const& x)
{
	return x + VAL;
}