STL源码学习笔记(1)：stack及自定义实现

     stack默认底层容器deque，对deque的几个成员函数进行了封装，所以实现比较简单。一种配接器，“接”就有接口的意思。详细参考《stl源码剖析》

1、stack底层源码，摘自SGI STL:stl_stack.h

#ifndef __SGI_STL_INTERNAL_STACK_H
#define __SGI_STL_INTERNAL_STACK_H

__STL_BEGIN_NAMESPACE

#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
template <class T, class Sequence = deque<T> >
#else
template <class T, class Sequence>
#endif

class stack {
　　//__STL_NULL_TMPL_ARGS宏展开为<>，c++ primer中文四版p555
　　//某种特化，赋予其相应模版实例的访问权
    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;   //底层容器Sequence = deque<T>
public:
    //利用deque判断是否空、得到大小、栈顶的引用
    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(); }
    //利用deque的尾部操作进行栈顶的出入栈
    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;   //调用了deque中相应成员
}

template <class T, class Sequence>
bool operator<(const stack<T, Sequence>& x, const stack<T, Sequence>& y) {
    return x.c < y.c;   //调用了deque中相应成员
}

__STL_END_NAMESPACE

#endif /* __SGI_STL_INTERNAL_STACK_H */

2、自定义stack类，功能包括：

出入栈、获得栈顶元素引用，判断栈是否空或满

#include <iostream>
#include <string>
//#define NDEBUG //断言开关
#include <cassert>
using namespace std;

template< class T >    
class Stack {
public:
   enum { DefaultStack = 50, EmptyStack = -1 };
   Stack();
   Stack( int );   
   ~Stack();

   void push( const T& );
   T pop();
   T topNoPop() const;  
   bool empty() const;  
   bool full() const;   
private:
   T* elements;
   int top;
   int size;
   void allocate() {    //动态分配
     elements = new T[ size ];
     top = EmptyStack;
   } 
   void msg( const char* m ) const {
     cout << "*** " << m << " ***" << endl;
   }
   friend ostream& operator<<( ostream&, const Stack< T >& );   
};

template< class T >
Stack< T >::Stack() {
   size = DefaultStack;
   allocate();
}

template< class T >
Stack< T >::Stack( int s ) {
   if ( s < 0 )       // 输入值不合法
     s *= -1;
   else if ( 0 == s ) 
     s = DefaultStack;
   size = s;
   allocate();
}

template< class T >
Stack< T >::~Stack() {
   delete[ ] elements;
}

template< class T >
void Stack< T >::push( const T& e ) {
   assert( !full() );
   if ( !full() )
     elements[ ++top ] = e;
   else
     msg( "Stack full!" );
}

template< class T >
T Stack< T >::pop() {
   assert( !empty() );
   if ( !empty() )
     return elements[ top-- ];
   else {
     msg( "Stack empty!" );
     T dummy_value;
     return dummy_value; // 返回随意值
   }
}

template< class T >
T Stack< T >::topNoPop() const {
   assert( top > EmptyStack );
   if ( !empty() )         //即使关掉断言也需要判断
     return elements[ top ];
   else {
     msg( "Stack empty!" );
     T dummy_value;
     return dummy_value;
   }
}

template< class T >
bool Stack< T >::empty() const {
   return top <= EmptyStack;
}

template< class T >
bool Stack< T >::full() const {
   return top + 1 >= size;
}

template< class T >
ostream& operator<<( ostream& os, const Stack< T >& s ) {
   s.msg( "Stack contents:" );
   int t = s.top;
   while ( t > s.EmptyStack )
     cout << s.elements[ t-- ] << endl;
   return os;   
}