C++顺序栈的模板类实现

#include <iostream>
#include <assert.h>
#define stackIncreament 20

template <class T>
class SeqStack{                      //顺序栈类定义
private:
    T* elements;			                            //栈元素存放数组
    int top;				                            //栈顶指针
    int maxSize;               		                    //栈最大容量
    void overflowProcess();	                            //栈的溢出处理
public:
    SeqStack(int sz = 50);		                        //构造函数
    SeqStack(const SeqStack<T>& a);                     //复制构造函数
    ~SeqStack() { delete[] elements; }                 //析构函数
    void Push(const T& x);	                            //进栈
    bool Pop(T& x);		                                //出栈
    bool getTop(T& x);		                            //取栈顶内容
    bool IsEmpty() const { return top == -1; }          //栈空
    bool IsFull() const { return top == maxSize - 1; }  //栈满
    int getSize() const { return top + 1; }             //栈中元素个数
    void MakeEmpty() { top = -1; }                      //清空栈
    //重载=操作符
    SeqStack& operator = (const SeqStack<T>& a) {
        if (this != &a) {
            delete[] elements;
            top = a.top;
            maxSize = a.maxSize;
            elements = new T[maxSize];
            assert(elements);
            for (int i = 0; i <= top; i++) {
                elements[i] = a.elements[i];
            }
        }
        return *this;
    }
};

//构造函数
template <class T>
SeqStack<T>::SeqStack(int sz)
{
    top = -1;
    maxSize = sz;
    elements = new T[maxSize];
    assert(elements);
}


//复制构造函数
template <class T>
SeqStack<T>::SeqStack(const SeqStack<T>& a)
{
    top = a.top;
    maxSize = a.maxSize;
    elements = new T[maxSize];
    assert(elements);    
    for (int i = 0; i <= top; i++) {
        elements[i] = a.elements[i];
    }
}

//溢出处理函数
template <class T>
void SeqStack<T>::overflowProcess() {
    //私有函数：当栈满则执行扩充栈存储空间处理
    T* newArray = new T[maxSize + stackIncreament];
    assert(newArray);                    //创建更大的存储数组
    for (int i = 0; i <= top; i++)
        newArray[i] = elements[i];
    maxSize += stackIncreament;
    delete[] elements;
    elements = newArray;  	//改变elements指针
}

//入栈
template <class T>
void SeqStack<T>::Push(const T& x) {
    //若栈不满, 则将元素x插入该栈栈顶, 否则溢出处理
    if (IsFull()) overflowProcess();      //栈满
    elements[++top] = x;	     //栈顶指针先加1, 再进栈
}

//出栈
template <class T>
bool SeqStack<T>::Pop(T& x) {
    //函数退出栈顶元素并返回栈顶元素的值
    if (IsEmpty()) return false;
    x = elements[top--];	     //栈顶指针退1
    return true;		     //退栈成功
}

//取栈顶
template <class T>
bool SeqStack<T>::getTop(T& x) {
    //若栈不空则函数返回该栈栈顶元素的地址
    if (IsEmpty()) return false;
    x = elements[top];
    return true;
}