c++简单的栈

Stack.h中声明了Stack类，在Stack.cpp中进行了定义
Stack的私有成员包括data指针，指向栈，tot指的是开辟总的空间，pointer指向类里面元素的位置
Stack有两个构造函数：不传参开辟大小为10的数组，传参按照参数开辟数组
Stack有两个状态函数判断栈是否为空或满（empty() full())
Stack功能：
push:未满存入目标元素，满了开辟两倍大小的数组再存入目标元素
pop:栈为空直接退出，否则抛弃栈顶元素
get():用于得到第i个元素，缺省为0
size():得到栈元素总数
[]重载：得到下标元素的值
print函数输出栈内所有元素,从栈底开始

Stack.h

#ifndef Stack_h
#define Stack_h
template <typename T>
class Stack
{
    T* data;
    int tot;  //开辟空间总数
    int pointer; //指针指向当前位置
public:
    Stack();
    Stack (int cnt);
    T pop();
    T get(int i = 0); //缺省值为0
    void push(const T &i);
    bool empty() //判断栈是否为空
    {
        return (pointer == 0);
    }
    bool full() //判断栈是否已满
    {
        return pointer == tot;
    }
    int size();
    T& operator[] (int i); //运算符重载
    void print();
    ~Stack();
};

#endif /* Stack_h */

Stack.cpp

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

template <typename T>
void Stack<T> :: print() //输出当前栈内所有元素
{
    for (int i = 0; i < pointer; i++)
        cout << data[i];
    cout << endl;
}

template <typename T>
Stack<T> :: Stack() : tot(10), pointer(0) //不带参数的构造函数
{
    data = new T[tot];
}

template <typename T>
T Stack<T> :: get(int i) //带参数的构造函数
{
    return data[pointer - 1 - i];
}

template <typename T>
void Stack<T> :: push(const T &i)
{
    if (!full())
    {
        data[pointer] = i;
        pointer++;
    }
    else //满了开辟两倍空间并复制原来的元素最后还复制回data
    {
        T* _data = new T[tot * 2];
        for (int k = 0; k < tot; k++)
            _data[k] = data[k];
        delete[] data;
        data = _data;
        data[pointer] = i;
        pointer++;
        tot *= 2;
    }
}

template <typename T>
T Stack<T> :: pop()
{
    if (empty())  //如果为空什么也不做
        return -1;
    T tep = data[pointer-1];
    pointer--;
    return tep;
}

template <typename T>
T& Stack<T> :: operator[] (int i)
{
    return data[pointer - i - 1];
}

template <typename T>
int Stack<T> :: size()
{
    return pointer;
}

template <typename T>
Stack<T> :: Stack (int cnt) : tot(cnt), pointer(0) { data = new T[tot]; }

template <typename T>
Stack<T> :: ~Stack() { delete[] data; }

smain.cpp

#include <iostream>
#include <string>
#include "Stack.h"
#include "Stack.cpp"
using namespace std;

int main()
{
    Stack<int> obj1; //int型对象
    Stack<int> obj2;
    obj2.pop();  //obj2为空,什么都不做
    for (int i = 0; i < 200; i++)
        obj1.push(i);
    cout << "obj1[0] = " << obj1[0] << endl;
    cout << "obj1.size() = " << obj1.size() << endl;
    cout << obj1.get(2) << endl;
    obj1.pop();
    cout << "obj1.size() = " << obj1.size() << endl;
    cout << obj1.get() << endl;
    cout << obj1.get(3) << endl;

    Stack<char> obj3; //创建存储char型的
    for (int i = 0; i < 20; i++)
        obj3.push('A' + i);
    cout << "obj3.size() = " << obj3.size() << endl;
    cout << "obj3[0] = " << obj3[0] << endl;
    cout << obj3.get()  << endl;
    cout << obj3.get(2) << endl;
    obj3.pop();
    cout << "obj3.size() = " << obj3.size() << endl;

    Stack<char> obj4(5);
    obj4.push('H');
    obj4.push('e');
    obj4.push('l');
    obj4.push('l');
    obj4.push('o');
    obj4.print();
    for(int i = 4; i >= 0; i--)
        cout << obj4[i];
    cout << endl;
    return 0;
}

smain函数的测试
两个不带参数的int型对象obj1，obj2。obj2没有push任何元素,pop()失败。obj2将0~199push进去并进行下面的测试
测试[]
测试size()
测试get(2)
测试pop删除
再次测试size()
测试get() 默认为第0个
测试get(3)

char型的obj3从A开始按顺序push了20个大写字母
测试size
测试[]
测试get() 默认第0个
测试get(2)
测试pop
再次测试size

char型的obj4(5) (指定开辟空间为5）push了H e l l o
测试print函数
测试obj4[]

最后输出为：
obj1[0] = 199
obj1.size() = 200
197
obj1.size() = 199
198
195
obj3.size() = 20
obj3[0] = T
T
R
obj3.size() = 19
Hello