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 booloperator== __STL_NULL_TMPL_ARGS (const stack&,const stack&);

       friend booloperator< __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 booloperator== __STL_NULL_TMPL_ARGS (const stack&,const stack&);

       friend booloperator< __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也没有迭代器

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

}