模拟实现 栈

栈：只允许在栈顶进行删除和插入操作的顺序表。（FILO，先进后出）
如下图：

在栈里面有以下几项基本操作：
pop（）//删除栈顶数据
push（data）//在栈顶插入一个数据data
top（）//返回栈顶元素
size（）//返回栈中元素的个数
empty（）//判断栈是否为空

下面进行代码实现：

#include<iostream>
using namespace std;

template <typename T>

class Stack
{
protected:
    T* _a;//存储数据
    int _size;//数据个数
    int _capacity;//容量

public:
    Stack()//构造函数
        :_a(NULL)
        ,_size(0)
        ,_capacity(0)
    {}

    Stack(const Stack<T>& S)//拷贝构造函数
        :_size(S._size)
        ,_capacity(S._capacity)
    {
        T* tmp = new T[S._capacity];
        for(size_t i = 0; i < S._size; i++)
        {
            tmp[i] = S._a[i];
        }
        _a = tmp;
    }

    ~Stack()//析构函数
    {
        delete[] _a;
        _a = NULL;
    }
    void Push(const T& data)//插入
    {
        _ChackCapacity();//判断容量是否够用
        _a[_size] = data;
        _size++;
    }
    void Pop()//删除
    {
        if(_size)
        {
            _size--;
        }
    }
    T& Top()//返回栈顶元素
    {
        if(_size)
        {
            return _a[_size-1];
        }

    }
    int _Size()//返回元素个数
    {
        return _size;
    }
    bool Empty()//判断栈是否为空
    {
        return !(_Size());
    }
    int _Capacity()//返回栈容量
    {
        return _capacity;
    }
protected:
    void _ChackCapacity()//增容
    {
        if(_size >= _capacity)
        {
            //NewCpacity为新的容量
            int NewCpacity = _capacity*2+3;//因为_capacity的初始值为0，所以这里加3
            T* tmp = new T[NewCpacity];//new 一块大小为NewCpacity的空间
            for(size_t i = 0; i < _size; i++)//将原先那块空间里的元素拷贝到新的空间里
            {
                tmp[i] = _a[i];
            }
            delete[] _a;//释放旧的空间
            _a = tmp;//让_a指向新的空间；
            _capacity = NewCpacity;//改变容量大小
        }
    }

};


int main()
{
    Stack<int> s;//构建一个整型的对象
    //插入1，2，3，4，5，6，六个对象
    s.Push(1);
    s.Push(2);
    s.Push(3);
    s.Push(4);
    s.Push(5);
    s.Push(6);
    //删除栈顶元素
    s.Pop();
    s.Pop();
    s.Pop();
    cout<<"容量："<<s._Capacity()<<endl<<endl;//返回栈的容量
    cout<<"元素数量："<<s._Size()<<endl<<endl;//返回栈中元素的数量
    s.Empty();//判断栈是否为空
    cout<<"栈中元素：";
    while(s._Size())//输出栈中元素
    {
        cout<<s.Top()<<" ";
        s.Pop();
    }
    cout<<endl<<endl;
    return 0;
}

结果：

因为在栈中只能访问栈顶元素，所以先打印栈顶元素，然后再将其删除，让倒数第二个数成为栈顶元素，在进行打印，以此类推。
缺点是在打印完元素栈也被清空了。