#include <iostream>
#include <fstream>
#include <cassert>
using namespace std;
///顺序栈
const int defaultSize=200;

template<class T>
class Stack
{
private:
    T* data;
    int maxSize;
    int top;
    void overProcess();

public:
    Stack(int sz=defaultSize);
    Stack(const Stack<T>& s);
    Stack<T>& operator=(const Stack<T>& s);
    ~Stack();

    void Push(const T &x);
    bool Pop(T& x);
    bool GetTop(T &x)const;
    bool IsEmpty()const;
    bool IsFull()const;

    int GetSize()const;
    void MakeEmpty();

    friend ostream& operator<<(ostream& out, const Stack<T>& s)
    {
        for(int i=0;i<=s.top;i++)
            cout<< s.data[i]<<‘ ‘;
        cout<<endl;
        return out;
    }
};

template<class T>
Stack<T>::Stack(int sz)
{
    top = -1;
    maxSize = sz;
    data = new T[maxSize];
}

template<class T>
Stack<T>::Stack(const Stack<T>& s)
{
    maxSize = s.GetSize();
     s.GetTop(top);
   // cout<<top;
    data = new T[maxSize];
    for(int i=0; i<=top; i++)
    {
        data[i] = s.data[i];
    }

}

template<class T>
Stack<T>& Stack<T>::operator=(const Stack<T>& s)
{
    maxSize = s.GetSize();
    s.GetTop(top);
    data = new T[maxSize];
   // cout<<top;
    for(int i=0; i<=top; i++)
    {
        data[i] = s.data[i];
    }
}

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

template<class T>
void Stack<T>::overProcess()
{
    T* newdt = new T[maxSize+defaultSize];
    for(int i=0; i<=top; i++)
    {
        newdt[i] = data[i];
    }
    maxSize += defaultSize;
    delete []data;
    data = newdt;
}

template<class T>
void Stack<T>::Push(const T &x)
{
    if(IsFull() == true)
        overProcess();
    top++;
    data[top] = x;
}

template<class T>
bool Stack<T>::Pop(T& x)
{
    if(IsEmpty() == true)
        return false;
    x = data[top];
    top--;
    return true;
}

template<class T>
bool Stack<T>::GetTop(T &x)const
{
    if(top == -1)
        return false;
    x = top;
    return true;
}

template<class T>
bool Stack<T>::IsEmpty()const
{
    if(top == -1)
        return true;
    return false;
}

template<class T>
bool Stack<T>::IsFull()const
{
    if(top == maxSize-1)
        return true;
    return false;
}

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

template<class T>
void Stack<T>::MakeEmpty()
{
    top = -1;
}

int main()
{
    Stack<int> sta;
    ifstream fin("data.txt");
    assert(fin);
    int data;
    while (!fin.eof())
    {
        assert(fin >> data);
        sta.Push(data);
    }

    cout << "The initial Stack in the file is:\n" << sta;
    cout << "The current size of the Stack is: " << sta.GetSize() << endl;
    sta.GetTop(data);
    cout << "The current Top of the Stack is : " << data << endl;
    cout << endl;
    Stack<int> s=sta;
    cout<<"运算符=重载："<<s<<endl;
    int x;
    sta.Pop(x);
    cout << "\nDo a Pop operation, then the stack is:\n" << sta << endl;
    cout << "the pop number is:" << x << endl;

    sta.GetTop(data);
    cout << "The current Top of the Stack is : " << data << endl;

    cout << "\nTest the state of the stack:\n";
    if (sta.IsEmpty())
        cout << "The stack is empty now!\n";
    else if (sta.IsFull())
        cout << "The stack is full now!\n";
    else
        cout << "The stack is not empty and not full now!\n";
    cout << "Now make the stack empty, then the state of the stack is:\n";



    sta.MakeEmpty();
    if (sta.IsEmpty())
        cout << "The stack is empty now!\n";
    else if (sta.IsFull())
        cout << "The stack is full now!\n";
    else
        cout << "The stack is not empty and not full now!\n";



    return 0;
}

#include <iostream>
#include <fstream>
#include <cassert>

using namespace std;

template <typename T>
struct StackNode
{
    T data;
    StackNode<T> *link;
    StackNode(T d = 0, StackNode<T> *next = NULL):link(next),data(d) {}
};

template <typename T>
class LinkedStack
{
private:
    StackNode<T> *top;
public:
    LinkedStack():top(NULL){}
    ~LinkedStack();
    void Push(const T &x);
    bool Pop(T &x);
    bool GetTop(T &x)const;
    int GetSize()const;
    bool IsEmpty()const;
    bool IsFull()const;
    void MakeEmpty();
    friend ostream& operator << (ostream &os, const LinkedStack<T> &s)
    {
        StackNode<T>* t = s.top;
        while(t != NULL)
        {
            cout<<t->data<<‘ ‘ ;
            t=t->link;
        }
        cout<<endl;
    }
};

template <typename T>
LinkedStack<T>::~LinkedStack()
{
    MakeEmpty();
}

template <typename T>
void LinkedStack<T>::Push(const T &x)
{
    top = new StackNode<T>(x,top);
}

template <typename T>
bool LinkedStack<T>::Pop(T& x)
{
    if(IsEmpty() == true)
        return false;
    StackNode<T>* t = top;
    top = top->link;
    x = t->data;
    delete t;
    return true;
}

template <typename T>
bool LinkedStack<T>::GetTop(T &x)const
{
    if(IsEmpty() == true)
        return false;
    x = top->data;
    return true;
}

template <typename T>
int LinkedStack<T>::GetSize()const
{
    StackNode<T>* t = top;
    int s=0;
    while(t!=NULL)
    {
        t = t->link;
        s++;
    }
    return s;
}

template <typename T>
bool LinkedStack<T>::IsEmpty()const
{
    if(top == NULL)
        return true;
    return false;
}

template <typename T>
bool LinkedStack<T>::IsFull()const
{
    return false;
}

template <typename T>
void LinkedStack<T>::MakeEmpty()
{
    StackNode<T>* t;
    while(top!=NULL)
    {
        t = top;
        top = top->link;
        delete t;
    }
}


int main()
{
    LinkedStack<int> sta;
    ifstream fin("data.txt");
    assert(fin);
    int data;

    while (!fin.eof())
    {
        assert(fin >> data);
        sta.Push(data);
    }

    cout << "The initial Stack in the file is:\n" << sta;
    cout << "The current size of the Stack is: " << sta.GetSize() << endl;

    sta.GetTop(data);
    cout << "The current Top of the Stack is : " << data << endl;

    int x;
    sta.Pop(x);
    cout << "\nDo a Pop operation, then the stack is:\n" << sta << endl;
    cout << "The data popped is: " << x << endl;
    sta.GetTop(data);
    cout << "The current Top of the Stack is : " << data << endl;

    cout << "\nTest the state of the stack:\n";
    if (sta.IsEmpty())
        cout << "The stack is empty now!\n";
    else if (sta.IsFull())
        cout << "The stack is full now!\n";
    else
        cout << "The stack is not empty and not full now!\n";

    sta.MakeEmpty();
    cout << "Now make the stack empty, then the state of the stack is:\n";
    if (sta.IsEmpty())
        cout << "The stack is empty now!\n";
    else if (sta.IsFull())
        cout << "The stack is full now!\n";
    else
        cout << "The stack is not empty and not full now!\n";
    return 0;
}