模版编程--类模版

类模版

1、模版编程也叫泛型编程，及不指定类型，当用时在标明类型。

2、模版类函数最好吧声明和定义写在一起，这样不至于在每个函数前都声明模版。

3、在编译时，编译器会自动处理模版类的重定义问题，所以不用进行模版类的预处理。

4、模版类可以特殊化，如下例：

#include <iostream>
using namespace std;
#include <typeinfo>
template < typename T=int, int len=10 >
class Stack{
    T a[len];
    int cur;
public:
    const char* element()const{return typeid(T).name();}
    int max_size()const{return len;}
    Stack():cur(0){}
    void push(const T& d)throw(const char*){//数据入栈成为栈顶
        if(full()) throw "满";
        a[cur++] = d;
    }
    T pop()throw(const char*){//栈顶数据出栈，下一个数据成为栈顶
        if(empty()) throw "空";
        return a[--cur];
    }
    const T& top()const throw(const char*){//取得栈顶数据
        if(empty()) throw "空";
        return a[cur-1];
    }
    bool empty()const{return cur==0;}//是否空栈
    bool full()const{return cur==5;}//是否已满
    void clear(){cur=0;}//栈清空（复位）
    int size()const{return cur;}//栈中数据个数
};
template <int len>
class Stack<const char*,len>{//部分特化
    string a[len];
    int cur;
public:
    const char* element()const{return "const char*";}
    int max_size()const{return len;}
    Stack():cur(0){}
    void push(const char* d)throw(const char*){//数据入栈成为栈顶
        if(full()) throw "满";
        a[cur++] = d;
    }
    const char* pop()throw(const char*){//栈顶数据出栈，下一个数据成为栈顶
        if(empty()) throw "空";
        return a[--cur].c_str();
    }
    const char*& top()const throw(const char*){//取得栈顶数据
        if(empty()) throw "空";
        return a[cur-1].c_str();
    }
    bool empty()const{return cur==0;}//是否空栈
    bool full()const{return cur==len;}//是否已满
    void clear(){cur=0;}//栈清空（复位）
    int size()const{return cur;}//栈中数据个数
};
int main()
{
    Stack<int> i;
    i.push(1);i.push(2);i.push(3);
    while(!i.empty()) cout << i.pop() << endl;
    char buf[100];
    Stack<const char*> s;
    for(;;){
        cin >> buf;
        if(strcmp(buf,"end")==0) break;
        s.push(buf);
    }
    cout << "=============" << endl;
    while(!s.empty()) cout << s.pop() << endl;
}

1、模版类也可以当做函数使用，例如用于递归，当n等于0和不等于0两种情况时。
2、模版类比较灵活，会自动搜寻与他匹配的类型，比如类型或指针匹配。

#include <iostream>
using namespace std;
#include <typeinfo>
template <int n>
class Fact{
public:
    enum {val=Fact<n-1>::val*n};
};
template <>
class Fact<0>{
public:
    enum {val=1};
};
template < typename T >
class Type{
public:
    static string name(){return typeid(T).name();}
};
template <>
class Type<char>{
public:
    static string name(){return "char";}
};
template <>
class Type<double>{
public:
    static string name(){return "double";}
};
template <>
class Type<int>{
public:
    static string name(){return "int";}
};
template <>
class Type<bool>{
public:
    static string name(){return "bool";}
};
template <typename T>
class Type<T*>{
public:
    static string name(){return Type<T>::name()+" pointer";}
};

int main()
{
    cout << Fact<5>::val << endl;
    cout << Type<double>::name() << endl;
    cout << Type<char>::name() << endl;
    cout << Type<bool>::name() << endl;
    cout << Type<int*>::name() << endl;
    cout << Type<double*>::name() << endl;
    cout << Type<bool**>::name() << endl;
}