stl源码剖析 详细学习笔记stack queue

//

//  stack.cpp

//  笔记

//

//  Created by fam on 15/3/15.

//

//

//---------------------------15/03/15----------------------------

//stack

{

    /*  

        stack概述:

     

        stack只采用deque的底部操作，封装了deque,形成stack

        这种方式是常见的adapter设计模式,stack往往不被归类为container

        而是被归类为 container adapter

    */

    

    template <class T, class Sequence = deque<T> >

    class stack

    {

        friend bool operator== __STL_NULL_TMPL_ARGS (const stack&, const stack&);

        friend bool operator< __STL_NULL_TMPL_ARGS (const stack&, const stack&);

        

    public:

        typedef typename Sequence::value_type value_type;

        typedef typename Sequence::size_type size_type;

        typedef typename Sequence::reference reference;

        typedef typename Sequence::const_reference const_reference;

        

    protected:

        Sequence c;

        

    public:

        

        bool empty() const{ return c.empty();}

        size_type size() const {return c.size();}

        reference top() {return c.back();}

        const_reference top() const {return c.back();}

        void push(const value_type& x) {c.push_back(x);}

        void pop() {c.pop_back();}

        

        

    };

    

    template<class T, class Sequence>

    bool operator==(const stack<T,Sequence>& x, const stack<T, Sequence>& y)

    {

        return x.c == y.c;

        

    }

    

    template<class T, class Sequence>

    bool operator<(const stack<T,Sequence>& x, const stack<T, Sequence>& y)

    {

        return x.c<y.c;

    }

    

    

    //stack没有迭代器,所有的元素都必须符合先进后出的条件，所以不提供访问其他元素的迭代器

    

}

//queue

{

    //queue 先进后出 可以用deque作为底层结构

    

    

    template <class T, class Sequence = deque<T> >

    class queue

    {

        friend bool operator== __STL_NULL_TMPL_ARGS (const stack&, const stack&);

        friend bool operator< __STL_NULL_TMPL_ARGS (const stack&, const stack&);

        

    public:

        typedef typename Sequence::value_type value_type;

        typedef typename Sequence::size_type size_type;

        typedef typename Sequence::reference reference;

        typedef typename Sequence::const_reference const_reference;

        

    protected:

        Sequence c;

        

    public:

        

        bool empty() const{ return c.empty();}

        size_type size() const {return c.size();}

        reference front() {return c.front();}

        const_reference front() const {return c.front();}

        reference back(){return c.back();}

        const_reference back() const {return c.back();}

        

        void push(const value_type& x){c.push_back(x);}

        void pop() {c.pop_front();}

    };

    

    template<class T, class Sequence>

    bool operator==(const stack<T,Sequence>& x, const stack<T, Sequence>& y)

    {

        return x.c == y.c;

        

    }

    

    template<class T, class Sequence>

    bool operator<(const stack<T,Sequence>& x, const stack<T, Sequence>& y)

    {

        return x.c<y.c;

    }

    

    //queue也没有迭代器

  //总结: 这两个数据结构毫无难度

}