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

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

#include <iostream>
#include <stack>
#include <queue>
using namespace std;

//Queue
template<typename T>
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<T> left_,right_;
};

template<typename T>
void Queue<T>::left_to_rigth(void)
{
    while(!left_.empty())
    {
        right_.push(left_.top());
        left_.pop();
    }
}

template<typename T>
bool Queue<T>::empty(void) const
{
    return (left_.empty() && right_.empty());
}

template<typename T>
void Queue<T>::push(const T& t)
{
    left_.push(t);
}

template<typename T>
void Queue<T>::pop(void)
{
    if (!right_.empty())
    {
        right_.pop();
    }
    else if (!left_.empty())
    {
        left_to_rigth();
    }
    else
    {
        throw "Queue is empty now ,can not pop!";
    }
}

template<typename T>
const T& Queue<T>::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<typename T>
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<T> left_,right_;
};

template<typename T>
void Stack<T>::left_to_rigth(void)
{
    if (!left_.empty())
    {
        int move = left_.size() -1;
        while (move > 0)
        {
            right_.push(left_.front());
            left_.pop();
            --move;
        }
    }
}

template<typename T>
bool Stack<T>::empty()
{
    return (left_.empty() && right_.empty());
}

template<typename T>
void Stack<T>::push(const T& t)
{
    left_.push(t);
}

template<typename T>
void Stack<T>::pop(void)
{
    left_to_rigth();
    left_.swap(right_);
    right_.pop();
}

template<typename T>
const T& Stack<T>::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<int> queue_int;
    cout<<"test queue : ";
    for(int i=0;i<10;++i)
    {
        queue_int.push(i);
    }
    while(!queue_int.empty())
    {
        cout<<queue_int.front()<<" ";
        queue_int.pop();
    }
    cout<<endl;

    Stack<int> stack_int;
    cout<<"test stack : ";
    for(int i=0;i<10;++i)
    {
        stack_int.push(i);
    }
    while(!stack_int.empty())
    {
        cout<<stack_int.top()<<" ";
        stack_int.pop();
    }
    cout<<endl;
    return 0;
}