p137 E2

原程序定义了新的Stack 类 new_copy，会在执行完这段程序后，自动析构，将tope_node指向的内容析构掉。

并且原程序没有对旧的top_node进行delete，造成内存流失。

 

#include<iostream>
using namespace std;
typedef char c;
enum aa {success,underflow,overflow};
struct Node
{
 c entry;
 Node *next;
 Node()
 {
  next=NULL;
 }
 Node(c item,Node *a=NULL)
 {
  entry=item;
  next=a;
 }
 
};
class Stack
{
public:
 Stack()
 {
  
  top_node=NULL;

 }
 bool empty()const
 {
  if(top_node==0)
   return true;
  return false;
 }
 aa push(const c &item)
 {
  Node *new_top=new Node(item,top_node);
  if(new_top==NULL)return overflow;
  top_node=new_top;
  return success;
 }
 aa pop()
 {
  Node*old_top=top_node;
  if(top_node==NULL)return underflow;
  top_node=top_node->next;
  delete old_top;
  return success;
 }
 aa top(c &item)
 {
  if(top_node==NULL)
  {
   return underflow;
  }
  item=top_node->entry;
  printf("%c\n",item);
  return success;
 }
 Stack (const Stack &original)
 {
  Node*new_copy,*original_node=original.top_node;
  if(original_node==NULL)
   top_node=NULL;
  else
  {
   top_node=new_copy=new Node(original_node->entry);
   while(original_node->next!=NULL)
   {
    original_node=original_node->next;
    new_copy->next=new Node(original_node->entry);
    new_copy=new_copy->next;
   }
  }
 }
 ~Stack()
 {
  while(!empty())
   pop();
 }
 void operator = (const Stack &original);
protected:
 Node*top_node;
};
void Stack::operator = (const Stack &original)
 {
  Stack new_copy(original);
  Node*p;
  p=new_copy.top_node;
  top_node=new_copy.top_node;
  new_copy.top_node=p;
 }
int main()
{
 char item;
 Stack a;
 a.push('2');
 Stack b(a);
 Stack c=b;
 c.top(item);
 return 0;
}