模板之类模板1

类模板：将类定义中的数据类型参数化。类模板实际上是函数模板的推广，可以用相同的类模板来组建任意类型的对象集合。

使用类模板，类模板的实例化：用具体的数据类型替换模板参数以得到具体的类。模板类也可以实例化为对象，用下列方式创建类模板的实例：

类名 <类型实参表> 对象名称

函数模板可以自动推导，类模板只能显示实例化。

下面以一个stack模板类来介绍模板的基本用法：

#pragma once
#include<exception>
template <typename T>
class Stack
{
public:
    Stack(int maxSize);
    ~Stack();
    void push(const T& elem);
    void pop();
    T& top();
    const T& top() const;
    bool empty() const;
private:
    T* elem_;
    int maxSize_;//栈最大元素个数
    int top_;//保存栈顶位置
};
template<typename T>
Stack<T>::Stack(int maxSize) :maxSize_(maxSize),top_(-1)
{
    elem_ = new T[maxSize_];
}
template<typename T>
Stack<T>::~Stack()
{
    delete[] elem_;
}
template<typename T>
void Stack<T>::push(const T& elem)
{
    if (top_ + 1 >= maxSize_)
        throw out_of_range("stack<>::push satck full");
    elem_[++top_] = elem;
}
template<typename T>
void Stack<T>::pop()
{
    if (top_ + 1 <= 0)
        throw out_of_range("stack<>::pop stack empty");
    --top_;
}
template<typename T>
T& Stack<T>::top()
{
    if (top_ + 1 == 0)
        throw out_of_range("stack<>::top() stack empty");
    return elem_[top_];
}
template<typename T>
const T& Stack<T>::top() const
{
    if (top_ + 1 == 0)
        throw out_of_range("stack<>::top() stack empty");
    return elem_[top_];
}
template<typename T>
bool Stack<T>::empty() const
{
    return top_ + 1 == 0;
}

#include<iostream>
#include "Stack.h"
using namespace std;


int main(void)
{
    Stack<int> s(10);
    s.push(1);
    s.push(2);
    s.push(3);
    while (!s.empty())
    {
        cout << s.top() << endl;
        s.pop();
    }
    return 0;
}

下面对上述类模板进行改进，引入非类型参数：

#pragma once
#include<exception>
//类模板也可以传递非类型参数
template <typename T,int MAX_SIZE>
class Stack
{
public:
    Stack();
    ~Stack();
    void push(const T& elem);
    void pop();
    T& top();
    const T& top() const;
    bool empty() const;
private:
    T* elem_;
    //int maxSize_;//栈最大元素个数
    int top_;//保存栈顶位置
};
template <typename T, int MAX_SIZE>
Stack<T,MAX_SIZE>::Stack() :top_(-1)
{
    elem_ = new T[MAX_SIZE];  
}
template <typename T, int MAX_SIZE>
Stack<T, MAX_SIZE>::~Stack()
{
    delete[] elem_;
}
template <typename T, int MAX_SIZE>
void Stack<T, MAX_SIZE>::push(const T& elem)
{
    if (top_ + 1 >= MAX_SIZE)
        throw out_of_range("stack<>::push satck full");
    elem_[++top_] = elem;
}
template <typename T, int MAX_SIZE>
void Stack<T, MAX_SIZE>::pop()
{
    if (top_ + 1 <= 0)
        throw out_of_range("stack<>::pop stack empty");
    --top_;
}
template <typename T, int MAX_SIZE>
T& Stack<T, MAX_SIZE>::top()
{
    if (top_ + 1 == 0)
        throw out_of_range("stack<>::top() stack empty");
    return elem_[top_];
}
template <typename T, int MAX_SIZE>
const T& Stack<T, MAX_SIZE>::top() const
{
    if (top_ + 1 == 0)
        throw out_of_range("stack<>::top() stack empty");
    return elem_[top_];
}
template <typename T, int MAX_SIZE>
bool Stack<T,MAX_SIZE>::empty() const
{
    return top_ + 1 == 0;
}

 　　进一步，类模板还可以传递内部数据类型。类似于适配器。如下面的例子：

#pragma once
#include<exception>
#include<deque>
using namespace std;
//类模板可以传递内部数据类型.适配器
//代码复用不是通过继承，而是通过适配
template <typename T,typename CONT=deque<T> >
class Stack
{
public:
    Stack() :c_() {}
    ~Stack() {}
    void push(const T& elem)
    {
        c_.push_back(elem);
    }
    void pop()
    {
        c_.pop_back();
    }
    T& top()
    {
        return c_.back();
    }
    const T& top() const
    {
        return c_.back();
    }
    bool empty() const
    {
        return c_.empty();
    }
private:
    CONT c_;
};


#include"Stack.h"
#include<iostream>
#include<vector>
int main()
{
    //Stack<int> s;
    Stack<int, vector<int> >s;
    s.push(1);
    s.push(2);
    s.push(3);
    while (!s.empty())
    {
        cout << s.top() << endl;
        s.pop();
    }
    return 0;
}