template相关

　　template模板是c++中支持多态的工具，使用模板可以使用户为类或函数声明一种一般的模式，使得该模板试用于任意类型的参数。

　　函数模板：

　　定义如下：

template <typename T>
void swap(T& a , T& b){
    T temp;
    temp = a;
    a = b;
    b = temp;        
}

　　使用如下：

#include<stdio.h>
int main(){
    int num1 = 0, num2 = 1;
    swap<int>(num1 , num2);
    printf("num1=%d,num2=%d
",num1,num2);
    return 0;  
}

　　类模版：

　　如果有两个类，其功能是相同的，仅仅是因为其数据结构不同，就可以通过声明一个类模版，他可以有一个或者多个虚拟的类型参数；这样就能实现“一类多用”。由于类模板包含类型参数，因此又称为参数化的类。如果说类是对象的抽象，对象是类的实例，则类模板是类的抽象，类是类模板的实例。利用类模板可以建立含各种数据类型的类。

　　与普通的类相比，类模版主要有下面两处不同：

　　1、在声明类模版时要加上template<class T>；

　　2、原有所有的类型名如int，都要换成虚拟类型参数名T；

　　定义如下：

template<class T>
class Stack{
public:
    Stack();
    ~Stack();
    void push(T t);
    T pop();
    bool isEmpty();
private:
    int m_maxSize ;
    int m_size ;
    T *m_pT ;
}

template <class  T>  Stack<T>::Stack(){
   m_maxSize = 100;      
   m_size = 0;
   m_pT = new T[m_maxSize];
}
template <class T>  Stack<T>::~Stack() {
   delete [] m_pT ;
}
        
template <class T> void Stack<T>::push(T t) {
    m_size++;
    m_pT[m_size - 1] = t;
    
}
template <class T> T Stack<T>::pop() {
    T t = m_pT[m_size - 1];
    m_size--;
    return t;
}
template <class T> bool Stack<T>::isEmpty() {
    return m_size == 0;
}

　　类模版使用：

#inlcude<stdio.h>

int main(){
    Stack<int> intStack;
    intStack.push(1);
    intStack.push(2);
    intStack.push(3);
    
    while (!intStack.isEmpty()) {
        printf("num:%d
", intStack.pop());
    }
    return 0;
}    

　　

　　类模板的类型参数可以有一个或多个，每个类型前面都必须加class，如

template <class T1,class T2>

class someclass

{…};

　　模版参数：

　　模板除了有类型参数，也可以有普通的参数，也可以有默认的模板参数，例如：

template<class T, T def_val> 
class Stack{...}

　　如果想要对类模版的对象数量进行限制，可是使用int参数来配置这个累的最大对象数，如下：

template <class T,int maxsize = 100> class Stack {
    public:
        Stack();
        ~Stack();
        void push(T t);
        T pop();
        bool isEmpty();
    private:
        T *m_pT;        
        int m_maxSize;
        int m_size;
};

template <class T,int maxsize> Stack<T, maxsize>::Stack(){
   m_maxSize = maxsize;      
   m_size = 0;
   m_pT = new T[m_maxSize];
}
template <class T,int maxsize>  Stack<T, maxsize>::~Stack() {
   delete [] m_pT ;
}
        
template <class T,int maxsize> void Stack<T, maxsize>::push(T t) {
    m_size++;
    m_pT[m_size - 1] = t;
    
}
template <class T,int maxsize> T Stack<T, maxsize>::pop() {
    T t = m_pT[m_size - 1];
    m_size--;
    return t;
}
template <class T,int maxsize> bool Stack<T, maxsize>::isEmpty() {
    return m_size == 0;
}

　　使用如下：

#include <stdio.h>
int main() {
    int maxsize = 1024;
    Stack<int,1024> intStack;
    for (int i = 0; i < maxsize; i++) {
        intStack.push(i);
    }
    while (!intStack.isEmpty()) {
        printf("num:%d
", intStack.pop());
    }
    return 0;
}