C++实现栈

#ifndef UNTITLED_STACK_H
#define UNTITLED_STACK_H
#include <iostream>
template<typename T>
class Stack{
private:
    int Size;//当前大小
    int Capacity;//容量
    int Top;
    T *data;
public:
    ~Stack();
    Stack(int size = 100);
    T pop();//出栈
    void push(const T x);//入栈
    int size();//返回大小
    int capacity();//返回容量
    void clear();//清空栈
    bool empty();//判空
    bool full();//判满
    T top();//栈顶
    void destroy();//销毁栈
    void reSize(int n);//调整容量
    Stack &operator=(const Stack &s);//拷贝赋值函数
};

template<typename T>
Stack<T>::Stack(int size){
    Top = -1;
    Size = 0;
    this->Capacity = size;
    data = new T[size];
}
template<typename T>
Stack<T>::~Stack<T>() {
    destroy();
}

//入栈
template<typename T>
void Stack<T>::push(const T x){
    if (full())
        reSize(2 * Capacity);
    ++Size;
    data[++Top] = x;
}

//出栈
template<typename T>
T Stack<T>::pop(){
    if (!empty()){
        std::cerr << "栈空的，无法出栈!\n";
        return 0;
    }
    --Size;
    return data[Top--];
}

//返回大小
template<typename T>
int Stack<T>::size(){
    return this->Size;
}

//返回容量
template<typename T>
int Stack<T>::capacity(){
    return this->Capacity;
}

//清空栈
template<typename T>
void Stack<T>::clear(){
    this->Size = 0;
    this->Top = -1;
}

//判空
template<typename T>
bool Stack<T>::empty(){
    return Size;
}

//判满
template<typename T>
bool Stack<T>::full(){
    return Size == Capacity;
}

//栈顶
template<typename T>
T Stack<T>::top(){
    if (!empty()){
        std::cerr << "栈空的，没有栈顶!\n";
        return 0;
    }
    return data[Top];
}

//销毁栈
template<typename T>
void Stack<T>::destroy(){
    if (data)
        delete [] this->data;
    data = nullptr;
    Size = 0;
    Capacity = 0;
    Top = -1;
}

//调整容量
template<typename T>
void Stack<T>::reSize(int n){
    T *p = new T[n];
    for (int i = 0; i < Capacity; ++i) {
        p[i] = data[i];//如果是对象必须有拷贝赋值函数
    }
    Capacity = n;
    delete [] data;
    data = p;
}

//拷贝赋值函数
template<typename T>
Stack<T> &Stack<T>::operator=(const Stack &s){
    if (data)
        destroy();
    Capacity = s.Capacity;
    data = new T[Capacity];
    Size = s.Size;
    for (int i = 0; i < s.Size; ++i) {
        data[i] = s.data[i];
    }
    Top = s.Top;
    return *this;
}

#endif //UNTITLED_STACK_H