所谓模板，实际上是建立一个通用函数或类，其类内部的类型和函数的形参类型不具体指定，用一个虚拟的类型来代表。这种通用的方式称为模板。

由以下三部分组成： 模板说明 + 函数定义 + 函数模板调用

template < 类型形式参数表 >
类型 函数名 (形式参数表)
{
//语句序列
}

是一个模板名。如果要把他看成一函数来使用，就要用一个类型来实例化这个模板，在使用时可以给其后尖括号中加上要使用的类型名，如下：

template
int compare(const T& a, const T& b) {
    if (a < b) {
        return -1; 
    }
    if (a > b) {
        return 1; 
    }
    return 0;
}

在使用时可以给其后尖括号中加上要使用的类型名，如下：

int main(){
    int a=1,b=2;
    double c=1.3,d=1.1;
    std::cout << compare(a,b) << std::endl;
    std::cout << compare(c,d) << std::endl;
    std::cout << compare(1.2,1.1)<< std::endl;
}

1.2特化模板函数 

有时通用的函数模板不能解决个别类型的问题，例如比较的是字符串，就需要加入一个特化模板函数对字符串进行特殊处理。

template<>
int compare(const char * const &str_a, const char * const 	&str_b)
{
    return strcmp(str_a,str_b);
}

std::cout << "对比字符串 "< 
结果： 
 
 
2.模板类（Stack） 
2.1模板类（Queue，Stack） 
类模板与函数模板的定义和使用类似，当有多个类，其功能是相同的，仅仅是数据类型不同时，我们可以使用类模板来实现。 
 
template 　　　　
 
class 类名{ ... };
 
const int size = 10;
template                     
class Stack{                          
public:
	void initStack()
	{
		top_ = -1;
	}
	void push(T ob);            
	T pop();                  
	~Stack(){
		top_ = -1;
        std::cout << "~Stack()" << std::endl;
    };
private:
  T stack[size];             
  int top_; 
};

template         
void Stack::push(T ob)         
{
	if(top_==size-1)
	{
		cout<<"栈满"<               
T Stack::pop()                  
{
	if(top_==-1)
   {
    cout<<"栈空"< s1;                       
 	s1.initStack();
 	s1.pop();
 	s1.push('a');
 	s1.push('b');
 	s1.push('c'); 
	s1.pop(); 

 	Stack s2;                        
 	s2.initStack();
 	s2.push(1);
 	s2.push(2);
 	s2.push(3); 
}
 

 2.2成员模板函数
 2.3模板特化：模板函数特化、模板成员函数特化、模板类特化 
 
 
3.模板类AutoPtr 
3.1构造函数 
template
AutoPtr::AutoPtr(T* pData)
{
    m_pData = pData;
    m_nUser = new int(1);
}
 
3.2析构函数 
template
AutoPtr::~AutoPtr()
{
    decrUser();
}
 
template
void AutoPtr::decrUser()
{
    --(*m_nUser);
    if((*m_nUser)==0){
        delete m_pData;
        m_pData = 0;
        delete m_nUser;
        m_nUser = 0;
    }
}
 
3.3拷贝构造函数 
AutoPtr& AutoPtr::operator=(const AutoPtr& h)
{
    decrUser();
    m_pData = h.m_pData;
    m_nUser = h.m_nUser;
    (*m_nUser)++;
}
 
3.4等号、->、*等运算符重载 
public:
    T* operator->(){
        return m_pData;
    }
    T& operator*(){
        return *m_pData;
    }
    const T& operator *() const{
        return *m_pData;
    }
    const T* operator ->() const{
        return m_pData;
    }
AutoPtr& AutoPtr::operator=(const AutoPtr& h)
{
    if(this==&h) return *this;
    decrUser();
    m_pData = h.m_pData;
    m_nUser = h.m_nUser;
    (*m_nUser)++;
    return *this;
}
 
3.5主函数调用AutoPtr