C++算法（7）数组实现栈

Others:

    #include <iostream>
    //栈的数组实现
    #include <cstdlib>   //提供exit()函数原型
    using namespace std;
    #define MAXSIZE  10  //define后面不需要“ ; ”的

    template<class T>
    class Stack
    {
    public:
        //默认构造函数
        Stack();
        Stack(size_t maxElements);  //size_t是 unsigned long 正数
        Stack(T data[], size_t maxElements); //都是构造函数，无需返回值
        // T data[]  的数据配型尚未确定，由传入实参决定
        ~Stack();

        //入栈
        void Push(T data);

        //出栈并返回
        T Pop();

        //返回栈顶元素
        T Top();

        //判断是否为空栈
        bool isEmpty();

        //栈是否已满
        bool isFull();

        //清空栈
        void Clear();

        //获得栈元素个数
        size_t GetSize();
    private:
        //栈标指示器
        size_t top;

        //数组
        T *arrays;   //指向  T  类型的指针

        //栈的容量
        size_t maxSize;
    };

    template<class T>
    Stack<T>::Stack() : maxSize(MAXSIZE), top(-1)
    //本来Stack函数能访问private元素，在开始就对maxSize和top进行了赋值。
    //相当于在函数内对这些元素赋值相同
    {
        arrays = new T[maxSize];
        if (arrays == NULL)
        {
            cout << "动态分配内存失败";
            exit(1); //强制退出程序
        }
    }

    template<class T>
    Stack<T>::Stack(size_t maxElements) : maxSize(maxElements), top(-1)
    {
        arrays = new T[maxSize];
        if (arrays == NULL)
        {
            cout << "动态分配内存失败";
            exit(1);
        }
    }

    template<class T>
    Stack<T>::Stack(T data[], size_t maxElements) : maxSize(maxElements), top(-1)
    {
        arrays = new T[maxSize];//创建存储栈的数组
        if (arrays == NULL)
        {
            cout << "动态分配内存失败";
            exit(1);
        }
        for (size_t i = 0; i < maxSize; i++)
        {
            arrays[i] = data[i];
        }
        top += maxSize;
    }

    template<class T>
    Stack<T>::~Stack()
    {
        delete[] arrays;
    }

    template<class T>
    void Stack<T>::Push(T data)
    {
        if (isFull())
        {
            throw runtime_error("Full stack");
            //throw将异常代码抛给runtime_error进行处理
        }
        else
        {
            top++;//指向栈顶
            arrays[top] = data;
        }
    }

    template<class T>
    T Stack<T>::Pop()
    {
        if (isEmpty())
        {
            throw runtime_error("No elements in the stack");
        }
        else
        {
            T data = arrays[top];
            top--;
            return data;
        }
    }

    template<class T>
    T Stack<T>::Top()
    {
        if (isEmpty())
        {
            throw runtime_error("No elements in the stack");
        }
        else
        {
            return arrays[top];
        }
    }

    template<class T>
    bool Stack<T>::isEmpty()
    {
        return top == -1;//判断语句
    }

    template<class T>
    bool Stack<T>::isFull()
    {
        return top == maxSize - 1;
    }

    template<class T>
    void Stack<T>::Clear()
    {
        while (Top != -1)
        {
            Top--;
        }
    }

    template<class T>
    size_t Stack<T>::GetSize()
    {
        return top + 1;
    }

    int main()
    {
        try//异常捕获
        {
            int a[6] = { 1, 2, 3, 4, 5, 6 };
            Stack<int> s(a, 6);  //s是class,初始化s
            s.Pop();       //出栈
            s.Push(7);     //入栈
            while (!s.isEmpty())
            {
                cout << s.Pop() << " ";
            }
            cout << endl;
        }
        catch (exception e)
        {
            cout << e.what() << endl;
        }
        system("pause");
        return 0;
    }

Me:

    #include<iostream>
    using namespace std;


    class Stack{
    private:
            int* arrays;
            int top = -1;
            int size_a = 10;
    public:
        Stack();

        Stack(int size);
        ~Stack();

        void Push(int data);
        int Pop();
        int get_size();
        int f_top();
        bool isEmpty();
        bool isFull();
        void clearStacks();

    };

    Stack::Stack():size_a(10), top(-1)
    {
        arrays = new int[size_a];
    }

    Stack::Stack(int size):size_a(size), top(-1)
    {
        cout << "It is here!" << endl;
        arrays = new int[size_a];
        //size_a = size;
    }

    Stack::~Stack(){
        delete [] arrays;
        }

    void Stack::Push(int data){
        if(isFull())
            cout << "The stack is full！" << endl;
        else
            arrays[++top] = data;
        }

    int Stack::Pop(){
        if(isEmpty())
            cout << "The stack is empty!" << endl;
        else
            return arrays[top--];
        }

    int Stack::get_size(){
        if(isEmpty()){
            cout << "The stack is empty!  ERROR" << endl;
            return 0;
        }
        else
            return top + 1;
        }

    int Stack::f_top(){
        return arrays[top];
        }

    bool Stack::isEmpty(){
        if(top == -1)
            return 1;
        else return 0;

        }

    bool Stack::isFull(){
        if(top >= size_a)
            return 1;
        else
            return 0;
        }
    void Stack::clearStacks(){
        while(top != -1)
            top--;
        }

    int main()
    {
        Stack s(9);
        //s.Stack(8);

        s.Push(2);
        s.Push(4);
        //for(int i = 0; i < s.get_size(); i++)
           // cout << s.arrays[i] << " " ;
        while(!s.isEmpty())
            cout << s.Pop();

        return 0;
    }