LinkStack class

11779 ワード

  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 }