栈

#ifndef NODE_H
#define NODE_H
template <typename T>
class node{
public:
    T data;
    node<T> *next;
public:
    node(T _data=0)
        : data(_data),next(nullptr){}
};
#endif // NODE_H

#ifndef STACK_H
#define STACK_H
#include <iostream>
#include "Node.h"
using namespace std;

template<typename T>
class Stack
{
public:
    Stack()
    {
        head = new node<T>;
        length=0;
    }

    Stack(int num)
    {
        head = new node<T>;
        length=0;
        for(int i=0;i<num;i++)
            insert(0);
    }

    Stack(const Stack& rhs)
    {
        head = new node<T>;
        length=0;
        node<T> *_node = rhs.head;
        for(int i=0;i<rhs.length;i++)
        {
            insert(_node->next->data);
            _node = _node->next;
        }
    }

    Stack &operator=(const Stack& rhs)
    {
        if(this == &rhs) return *this;

        int _length = this->length;
        for(int i=0;i<_length;i++)
        {
            erase();
        }
        head->next = nullptr;
        node<T> *_node = rhs.head;
        for(int i=0;i<rhs.length;i++)
        {
            insert(_node->next->data);
            _node = _node->next;
        }
        return *this;
    }

    virtual ~Stack()
    {
        int _length = length;
        for(int i=0;i<_length;i++)
            erase();
        delete head;
    }
public:
    void push(const T&_data)
    {
        insert(_data);
    }

    void pop()
    {
        erase();
    }

    T &top()
    {
        if(length==0)
            throw std::bad_alloc("bad_alloc");
        node<T>* top_node = head;
        int _length=length;
        while(_length > 0)
        {
            top_node = top_node->next;
            _length--;
        }
        return top_node->data;
    }

    bool empty() const
    {
        return length==0;
    }

    int size() const
    {
        return length;
    }
private:
    void insert(const T&_data)
    {
        node<T>* new_node = new node<T>(_data);
        node<T>* _head = head;
        int _length=length;
        while(_length > 0)
        {
            _head = _head->next;
            _length--;
        }
        _head->next = new_node;
        length++;
    }

    void erase()
    {
        if(empty()) return;
        node<T> *prev;
        node<T> *del_node = head;
        int _length = length;
        while(_length > 0)
        {
            prev = del_node;
            del_node = del_node->next;
            _length--;
        }
        prev->next = nullptr;
        delete del_node;
        length--;
    }

    friend ostream& operator <<(ostream &os,
                                const Stack<T> &stack)
    {
        node<T> *_node = stack.head->next;
        while(_node != nullptr)
        {
            os << _node->data << ",";
            _node = _node->next;
        }
        return os;
    }
private:
    node<T> *head;
    int length;
};
#endif // STACK_H