模板（二）

类模板

• 类模板：将类定义中的数据类型参数化

• 类模板实际上是函数模板的推广，可以用相同的类模板来组建任意类型的对象集合

       template <类型形参表>
       class <类名> 
       {
              //类说明体 
       }；
  
       template <类型形参表>
       <返回类型><类名><类型名表>:: <成员函数1>（形参表）
       {
              //成员函数定义体
       }；
  
       template <类型形参表>
       <返回类型><类名><类型名表>:: <成员函数2>（形参表）
       {
              //成员函数定义体
       }；
      ...
  
       template <类型形参表>
       <返回类型><类名><类型名表>:: <成员函数n>（形参表）
       {
              //成员函数定义体
       }；
  

#ifndef _STACK_H_
#define _STACK_H_

#include <exception>

template <typename T>
class Stack
{
public:
    explicit 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() Stack full.");
    elem_[++top_] = elem;
}

template <typename T>
void Stack<T>::Pop()
{
    if (Empty())
        throw out_of_range("Stack::Pop() Stack empty");
    --top_;

}

template <typename T>
T& Stack<T>::Top()
{
    if (Empty())
        throw out_of_range("Stack::Pop() Stack empty");
    return elem_[top_];

}

template <typename T>
const T& Stack<T>::Top() const
{
    if (Empty())
        throw out_of_range("Stack::Pop() Stack empty");
    return elem_[top_];

}

template <typename T>
bool Stack<T>::Empty() const
{
    return top_ + 1 == 0;
}

#endif // _STACK_H_

使用类模板

• 类模板的实例化：用具体的数据类型替换模板的参数以得到具体的类（模板类）
• 模板类也可以实例化为对象

• 用下列方式创建类模板的实例：

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

  类模板只能显示实例化

#include "Stack.h"
#include <iostream>

using namespace std;

int main(void)
{
    Stack<int> s(3);   //显示指定
    s.Push(1);
    s.Push(2);
    s.Push(3);

    while (!s.Empty())
    {
        cout << s.Top() << endl;
        s.Pop();
    }
    return 0;
}

非类型模板参数

---

• 对于函数模板与类模板，模板参数并不局限于类型，普通值也可以作为模板参数

---

#ifndef _STACK2_H_
#define _STACK2_H_

#include <exception>

template <typename T, int MAX_SIZE>    //MAX_SIZE也可作为模板参数
class Stack2
{
public:
    Stack2();                
    ~Stack2();
    void Push(const T& elem);
    void Pop();
    T& Top();
    const T& Top() const;
    bool Empty() const;
private:
    T* elem_;
    int top_;
};

template <typename T, int MAX_SIZE>
Stack2<T, MAX_SIZE>::Stack2() : top_(-1)     //Stack2<T, MAX_SIZE>
{
    elem_ = new T[MAX_SIZE];
}

template <typename T, int MAX_SIZE>
Stack2<T, MAX_SIZE>::~Stack2()
{
    delete[] elem_;
}

template <typename T, int MAX_SIZE>
void Stack2<T, MAX_SIZE>::Push(const T& elem)  //Stack2<T, MAX_SIZE>
{
    if (top_ + 1 >= MAX_SIZE)
        throw out_of_range("Stack2<>::Push() Stack2 full.");
    elem_[++top_] = elem;
}

template <typename T, int MAX_SIZE>
void Stack2<T, MAX_SIZE>::Pop()                //Stack2<T, MAX_SIZE>
{
    if (Empty())
        throw out_of_range("Stack2::Pop() Stack2 empty");
    --top_;

}

template <typename T, int MAX_SIZE>
T& Stack2<T, MAX_SIZE>::Top()                 //Stack2<T, MAX_SIZE>
{
    if (Empty())
        throw out_of_range("Stack2::Pop() Stack2 empty");
    return elem_[top_];

}

template <typename T, int MAX_SIZE>
const T& Stack2<T, MAX_SIZE>::Top() const    //Stack2<T, MAX_SIZE>
{
    if (Empty())
        throw out_of_range("Stack2::Pop() Stack2 empty");
    return elem_[top_];

}

template <typename T, int MAX_SIZE>
bool Stack2<T, MAX_SIZE>::Empty() const     //Stack2<T, MAX_SIZE>
{
    return top_ + 1 == 0;
}

#endif // _STACK2_H_