用两个栈实现一个队列，用两个队列实现一个栈，C++ STL版

不必解释了吧，这里代码应该就能说明问题了

#include 
  
   
#include 
   
     #include 
    
      using namespace std; //Queue template
     
       class Queue { public: void pop(void); void push(const T& t); const T& front(void); bool empty(void) const; private: void left_to_rigth(void); stack
      
        left_,right_; }; template
       
         void Queue
        
         ::left_to_rigth(void) { while(!left_.empty()) { right_.push(left_.top()); left_.pop(); } } template
         
           bool Queue
          
           ::empty(void) const { return (left_.empty() && right_.empty()); } template
           
             void Queue
            
             ::push(const T& t) { left_.push(t); } template
             
               void Queue
              
               ::pop(void) { if (!right_.empty()) { right_.pop(); } else if (!left_.empty()) { left_to_rigth(); } else { throw "Queue is empty now ,can not pop!"; } } template
               
                 const T& Queue
                
                 ::front(void) { if (!right_.empty()) { return right_.top(); } else if (!left_.empty()) { left_to_rigth(); return right_.top(); } else { throw "empty queu can not return front"; } } //Stack template
                 
                   class Stack { public: void pop(void); void push(const T& t); const T& top(void); bool empty(void); private: void left_to_rigth(void); queue
                  
                    left_,right_; }; template
                   
                     void Stack
                    
                     ::left_to_rigth(void) { if (!left_.empty()) { int move = left_.size() -1; while (move > 0) { right_.push(left_.front()); left_.pop(); --move; } } } template
                     
                       bool Stack
                      
                       ::empty() { return (left_.empty() && right_.empty()); } template
                       
                         void Stack
                        
                         ::push(const T& t) { left_.push(t); } template
                         
                           void Stack
                          
                           ::pop(void) { left_to_rigth(); left_.swap(right_); right_.pop(); } template
                           
                             const T& Stack
                            
                             ::top(void) { if (!left_.empty()) { left_to_rigth(); left_.swap(right_); const T& temp = right_.front(); left_.push(right_.front()); right_.pop(); return temp; } else { throw "empty stack can not return top!"; } } int main () { Queue
                             
                               queue_int; cout<<"test queue : "; for(int i=0;i<10;++i) { queue_int.push(i); } while(!queue_int.empty()) { cout<
                              
                                stack_int; cout<<"test stack : "; for(int i=0;i<10;++i) { stack_int.push(i); } while(!stack_int.empty()) { cout<