C++栈的数组

template<class Type>
    class stackADT
    {
        virtual void initializeStack()=0;//virtual和=0表明都是纯虚函数，抽象类中只能声明纯虚函数，不能定义
        virtual bool isEmptyStack() const=0;//const放在函数后面，表明该函数是常成员函数，在函数执行过程中不能改变函数内部变量的值
        virtual bool isFullStack() const=0;
        virtual void push(const Type&)=0;//引用常量，该函数不会自动对输入进行赋值，同时在函数内的操作也不能改变输入的值
        virtual void pop()=0;
        virtual Type top() const=0;//这里也采用常成员函数，因为函数不会对变量进行修改，只是返回变量
    };

template <class Type>
    class stackType:public stackADT<Type> //一定要记住每次用到模板类时不要忘记后面的<Type>
    {
        public:
        stackType(int stackSize=100);//注意这里用到了参数缺省构造函数中的参数缺省必须在声明函数时给出默认值而不能在定义函数时给出默认值；stackType作为函数名，因此后面不要加<Type>
        stackType(const stackType<Type>&); //拷贝构造函数
        ~stackType();
        const stackType<Type>& operator=(const stackType<Type>&);//重载赋值运算符
        void initializeStack();
        bool isEmptyStack()const;
        bool isFullStack()const;
        void push(const Type&);
        void pop();
        Type top()const;
        private:
        Type* list;//指向栈的首地址
        int maxStackSize;//栈的最大容量
        int stackTop;//栈顶元素的位置(从1开始)
        void copyStack(const stackType<Type>&);//执行深拷贝过程
    };//注意不要忘记分号

template<class Type>//在类外定义函数必须使用template，并且每定义一个函数就要写一次
void stackType<Type>::initializeStack()  //命名空间也不要忘记::,因为命名空间的名字是模板类，所以后面要有<Type>
{
    stackTop=0;//不需要把元素全部置零，只需要把栈顶元素的索引变成0即可
}

template<class Type>
bool stackType<Type>::isEmptyStack()const
{
    return !stackTop;//可以认为stackTop表示栈中目前元素的个数，为0则表示空栈
}

template<class Type>
bool stackType<Type>::isFullStack()const
{
    return stackTop==maxStackSize;
}

template<class Type>
void stackType<Type>::pop()
{
    if(!isEmptyStack())
        stackTop--;
    else
        cout<<"The stack is empty,cannot add to an item"<<endl;
}

template<class Type>
void stackType<Type>::pop()
{
    if(!isEmptyStack())
        stackTop--;
    else
        cout<<"The stack is empty,cannot add to an item"<<endl;
}

template<class Type>
Type stackType<Type>::top()const
{
    assert(!isEmptyStack());//如果栈为空那么必须终止程序，reuturn 返回的会是乱码，push和pop不需要这个操作是因为他们没有返回值，所以如果不满足执行的条件只需要在终端上显示出现异常就行。
    return list[stackTop-1];
}

template<class Type>
void stackType<Type>::copyStack(const stackType<Type>& otherStack)
{
    delete [] list;   //释放当前栈的内存,注意如果delete的是一个空指针，那么delete不会执行，因此就不需要判断是否为空指针
    stackTop=otherStack.stackTop;
    maxStackSize=otherStack.maxStackSize;
    list=new Type[maxStackSize];  //
    for(int i=0;i<stackTop;i++)
        list[i]=otherStack.list[i];
}

template<class Type>
stackType<Type>::stackType(int stackSize)
{
    if(stackSize<=0)
    {
        cout<<"The size must be positive"<<endl;
        cout<<"creating an array of size 100"<<endl;
        maxStackSize=100;
    }
    else
    {
        maxStackSize=stackSize;
    }
    stackTop=0;
    list=new Type[maxStackSize];
}

template<class Type>
stackType<Type>::stackType(const stackType<Type>& otherStack)
{
    list=nullptr;       //这里list必须置为空，因为在这个程序中，赋值栈的赋值触发的是运算符重载，而拷贝构造函数只有在作为函数输入参数时或者返回参数时才会被触发，同时由于拷贝构造函数是构造函数重载，所以在触发拷贝构造函数前并不会触发构造函数，也意味着并没有给list分配内存，那么list就是一个野指针，如果不置为空那么调用copyStack()时,由于copyStack中第一条语句就是delete []list;删除没有分配内存的野指针就会报错，所以list置为空是必须的
    copyStack(otherStack);
}

template<class Type>
const stackType<Type>& stackType<Type>::operator=(const stackType<Type>& otherStack)
{
    if(this!=&otherStack) //避免自我复制
    copyStack(otherStack);
    return *this;
}

template<class Type>
stackType<Type>::~stackType()
{
    delete [] list;
}

#include "stackADT.h"
//类的定义放在这里

#include<iostream>
#include<cassert>
#include "stackArr.h"
using namespace std;
//类的实现放在这里

#include "stackArr.cpp" //这里不能include "stackArr.h"，因为这里是模板类，模板类需要编译两次，
int main()
{
    //主函数的内容
    return 0;
}

#ifndef H_StackType
#define H_StackType
#include<iostream>
#include<cassert>
#include "stackADT"
using namespace std;
//类的定义如下
//此处写类的成员函数的实现
#endif