[数据结构]Linked_stack

//Link_Stack.h
#pragma once
enum Error_code{success,underflow,overflow};
template<class Stack_entry>
class Linked_Stack
{
public:
Linked_Stack();
bool empty()const;
Error_code pop();
Error_code top(Stack_entry &item)const;
Error_code push(const Stack_entry &item);
~Linked_Stack();
void operator=(const Linked_Stack &original);
Linked_Stack(const Stack_entry &item);
void print();
private:
struct Node
{
Node();
Node(const Stack_entry &item, Node *add_on = NULL);
Node *next;
Stack_entry entry;
};
Node *head;
};

template<class Stack_entry>
inline Linked_Stack<Stack_entry>::Node::Node()
{
next = NULL;
}

template<class Stack_entry>
inline Linked_Stack<Stack_entry>::Node::Node(const Stack_entry & item, Node * add_on)
{
next = add_on;
entry = item;
}

//Linked_stack.cpp
#include<iostream>
#include"Link_Stack.h"
using namespace std;

template<class Stack_entry>
Linked_Stack<Stack_entry>::Linked_Stack(){
head = NULL;
}

template<class Stack_entry>
bool Linked_Stack<Stack_entry>::empty() const
{
if (head)return true;
else return false;
}

template<class Stack_entry>
Error_code Linked_Stack<Stack_entry>::pop()
{
if (!head)return underflow;
Node *temp = head;
head = head->next;
delete temp;
return success;
}

template<class Stack_entry>
Error_code Linked_Stack<Stack_entry>::top(Stack_entry & item) const
{
if (head)return underflow;
item = head->entry;
return success;
}

template<class Stack_entry>
Error_code Linked_Stack<Stack_entry>::push(const Stack_entry & item)
{
head = new Node(item, head);
return success;
}

template<class Stack_entry>
Linked_Stack<Stack_entry>::~Linked_Stack()
{
while (head) {
Node *temp = head;
head = head->next;
delete temp;
}
}

template<class Stack_entry>
void Linked_Stack<Stack_entry>::operator=(const Linked_Stack & original)
{
Node *temp = original.head;
Linked_Stack <Stack_entry> middle;
if (head == original.head)return;
while (temp) {
middle.push(temp->entry);
temp = temp->next;
}
while (head) pop();
temp = middle.head;
while (temp) {
push(temp->entry);
temp = temp->next;
}
}
template<class Stack_entry>
Linked_Stack<Stack_entry>::Linked_Stack(const Stack_entry & original)
{
Node *new_head, *new_temp, *original_temp = original.head;
if (original == NULL) { new_head == NULL; return; }
new_temp = new_head = new Node(original_temp->entry);
while (original_temp) {
original_temp = original_temp->next;
new_temp->next = new Node(original_temp->entry);
new_temp = new_temp->next;
}
}

template<class Stack_entry>
void Linked_Stack<Stack_entry>::print()
{
Node *temp = head;
while (temp) {
cout << temp->entry << ' ';
temp = temp->next;
}
cout << endl;
}

//main.cpp
#include<iostream>
#include"Linked_Stack.cpp"
using namespace std;
void main() {
cout << "1.push test1." << endl;
cout << "2.push test2." << endl;
cout << "3.pop test1." << endl;
cout << "4.pop test1." << endl;
cout << "5.make test1=test2." << endl;
cout << "6.make test2=test1." << endl;
cout << "7.print test1." << endl;
cout << "8.print test2." << endl;
Linked_Stack<int> test1, test2;
while (1) {
int key=0;

cin >> key;
switch (key)
{
case 1: {
int item;
cout << "please cin item." << endl;
cin >> item;
test1.push(item);
cout << "--------------------------------------------------" << endl;
break;
}
case 2: {
int item;
cout << "please cin item." << endl;
cin >> item;
test2.push(item);
cout << "--------------------------------------------------" << endl;
break;
}
case 3:
test1.pop();
cout << "--------------------------------------------------" << endl;
break;
case 4:
test2.pop();
cout << "--------------------------------------------------" << endl;
break;
case 5:
test1 = test2;
cout << "--------------------------------------------------" << endl;
break;
case 6:
test2 = test1;
cout << "--------------------------------------------------" << endl;
break;
case 7:
test1.print();
cout << "--------------------------------------------------" << endl;
break;
case 8:
test2.print();
cout << "--------------------------------------------------" << endl;
break;
}
}
}