LinkStack class

  1 #include <cstddef>
  2 
  3 struct Node {
  4     Node * next;
  5 
  6     Node() { next = NULL;}
  7     Node(const Node & node) {
  8         next = node.next;
  9     }
 10 };
 11 
 12 enum Error_code {
 13     succeed,
 14     overflow,
 15     underflow
 16 };
 17 
 18 
 19 class LinkStack { // This class have no capacity limit
 20 public:
 21     LinkStack();
 22     LinkStack(const LinkStack & rhs);
 23     ~LinkStack();
 24 
 25     LinkStack & operator=(const LinkStack & rhs);
 26 
 27     Error_code push(const Node & item);
 28     Error_code pop();
 29     Error_code top(Node * item) const;
 30     bool empty() const;
 31 
 32 protected:
 33     Node * top_node;
 34 };
 35 
 36 LinkStack::LinkStack() {
 37 
 38 }
 39 
 40 LinkStack::LinkStack(const LinkStack & rhs) {
 41     Node * new_top, * new_copy, * old_node=rhs.top_node;
 42     if (old_node == NULL)
 43         new_top = NULL;
 44     else {
 45         new_top = new_copy = new Node(*old_node);
 46         while(old_node->next != NULL) {
 47             old_node = old_node->next;
 48             new_copy->next= new Node(*old_node);
 49             new_copy = new_copy->next;
 50         }
 51     }
 52 }
 53 
 54 LinkStack::~LinkStack() {
 55     while(!empty())
 56         pop();
 57 }
 58 
 59 Error_code LinkStack::push(const Node & item) {
 60     Node * new_top = new Node(item);
 61     if (new_top == NULL)
 62         return overflow;
 63     top_node = new_top;
 64     return succeed;
 65 }
 66 
 67 Error_code LinkStack::pop() {
 68     Node * old_top = top_node;
 69     if (top_node == NULL)
 70         return underflow;
 71     top_node = top_node->next;
 72     delete old_top;
 73     return succeed;
 74 }
 75 
 76 bool LinkStack::empty() const {
 77     if (top_node == NULL)
 78         return true;
 79     return false;
 80 }
 81 
 82 Error_code LinkStack::top(Node * item) const{
 83     if (top_node == NULL)
 84         return underflow;
 85     item = top_node;
 86     return succeed;
 87 }
 88 
 89 LinkStack & LinkStack::operator=(const LinkStack & rhs) {
 90     Node * new_top, * new_copy, * old_node=rhs.top_node;
 91     if (old_node == NULL)
 92         new_top = NULL;
 93     else {
 94         new_top = new_copy = new Node(*old_node);
 95         while (old_node->next != NULL) {
 96             old_node = old_node->next;
 97             new_copy->next = new Node(*old_node);
 98             new_copy = new_copy->next;
 99         }
100     }
101 
102     while(!empty())
103         pop();
104     top_node = new_top;
105 
106     return *this;
107 }