作业

E7

#include<iostream>

using namespace std;

const int maxqueue = 10;

class Queue{

public:  

Queue( );  

bool empty( ) const;  

Error_code serve( );  

Error_code append(const Queue_entry item);  

Error_code retrieve(Queue_entry item) const;

protected:  

int front,rear;  

Queue_entry entry [maxqueue];  

bool is_empty; };

Queue :: Queue( )

{rear = maxqueue-1;

front = 0;  

is_empty = true;}

bool Queue :: empty( ) const  

{return is_empty;}

Error_code Queue :: append(const Queue_entry item)  

if (!empty( )&&(rear+1)%maxqueue ==  front) return overflow;  

is_empty = false;  

rear=(rear+1)%maxquene; 

entry[rear]=item;  

return success; }

Error_code Queue :: serve( )

{if(empty( ))return underflow;  

if(rear==front)is_empty = true;  

front=((front+1)==maxqueue)?0:(front+1);  

return success;}

Error_code Queue::retrieve(Queue_entry item) const

{if(empty( ))return underflow;  

item=entry[front];  

return success;

}

 

 

 

 

 

 

 

E2（2）

 

Error_code copy_stack(Stack &dest,Stack &source)
{
Error_code detected=success;
Stack temp;
Stack_entry item;
while(detected==success&&!source.empty()}
{
    detected=source.top(item);
    detected=source.pop();
    if(detected==success)detected=temp.push(item);
  }
while (detected==success&&!temp.empty()
{
  detected=temp.top(itemp);
  detected=temp.pop();
  if (detected==success)detected=source.push(item);
  if (detected==success)detected=dest.push(item);
  }
return detected;
}