用两个stack定义一个queue

一个堆栈用于压如元素
另一堆栈弹出元素。如果一个弹出操作遇到空堆栈，那么就将入堆栈中的元素一次一个地传送到出堆栈中。

#include  " stdafx.h "
#include  < stack >

template < class  T,  class  C  =  std::vector < T >   >
class  Queue ... {
    public:
        typedef typename C::vaule_type vaule_type;
        typedef typename C::size_type  size_type;
        typedef typename C  conainer_type;

        explicit Queue(C const& contents = C())
            :outstack_(contents)...{}
        bool empty() const
        ...{return instack_.empty() && outstack_.empty(); }
        
        size_type size() const
        ...{return instack_.size() + outstack_.size(); }

        vaule_type& front()
        ...{ transfer(); return outstack_.top(); }
        vaule_type const& front()
        ...{ transfer(); return outstack_.top(); }

        vaule_type& back()
        ...{ untransfer(); return instack_.top(); }
        vaule_type const& back() const
        ...{ untransfer(); return instack_.top(); }

        void push(vaule_type const& x) ...{ instack_.push(x); }
        void pop()...{ transfer(); outstack_.pop(); }

    private:
        void transfer()...{
            if(outstack_.empty())
                while (!instack_.empty())...{
                    outstack_.push(instack_.top());
                    instack_.pop();
                }
        }

        void untransfer()...{
            assert(cerr <<"Warning: Queue::unteansfer()'ed. ");
            if(instack_.empty())
                while (!outstack_.empty())...{
                    instack_.push(outstack_top());
                    outstack_.pop();
                }
        }
        std::stack<T, C> instack_, outstack_;
        T* outbottom_;
} ;




int  main( int  argc,  char *  argv[])
... {
    return 0;
}