栈-顺序栈

MyStack.h

#ifndef _MYSTACK_H
#define _MYSTACK_H//定义保护防止多重包含

#include "MyUtil.h"

template<class T>
class MyStack{
public:
    MyStack(int stackCapacity = 10);//栈的长度默认为10
    ~MyStack();//析构函数

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

    T& Top() const;//记录栈顶元素

    void Push(const T& item);//将元素压入栈

    void Pop();//元素出栈

private:
    T *stack;//利用指针动态创建一个数组
    int top;//记录栈顶元素位置
    int capacity;//数组容量

};

template<class T>
inline bool MyStack<T>::IsEmpty() const{
    return top ==-1;
}

template<class T>
inline T& MyStack<T>::Top() const{
    if(IsEmpty()){
        throw "Stack is empty";
    }
    return stack[top];
}

template<class T>
MyStack<T>::MyStack(int stackCapacity):capacity(stackCapacity){
    if(capacity < 1){
        throw "stack capacity must be > 0";
    }
    stack = new T[capacity];
    top = -1;
}

template<class T>
MyStack<T>::~MyStack(){//析构函数
    delete[] stack;
}

template<class T>
void MyStack<T>::Push(const T& item){
    if(top == capacity-1){
        ChangeSize1D(stack,capacity,2*capacity);
        capacity *= 2;
    }
    stack[++top] = item;
}

template<class T>
void MyStack<T>::Pop(){
    if(IsEmpty()){
        throw "Stack is empty.Cannot delete";
    }
    top--;//此为简单删除。
    //如果堆栈保存的不是基本数据类型，而是一些 类 等。就不能简单删除。此时要用下面的方法
    stack[top--].~T();//将类删除后就要调用析构函数
}

#endif

MyUtil.h

#ifndef _MYUYIL_H
#define _MYUTIL_H

using namespace std;
template <class T>
//把数组放大一倍
void ChangeSize1D(T* &a, const int oldSize, const int newSize);

template<class T>
void ChangeSize1D(T* &a,const int oldSize,const int newSize){
    if(newSize<0){
        throw "New length must be >=0";
    }
    T* temp = new T[newSize];
    int number = min(oldSize,newSize);
    std::copy(a,a+number,temp);
    delete[] a;
    a = temp;
}

#endif // _MYUYIL_H

main.cpp

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

int main()
{
    MyStack<int> st;

    st.Push(99);
    st.Push(22);

    cout << "Hello world!" <<st.Top()<< endl;
    return 0;
}