Man Page stack.3

                       Standard C++ Library
             Copyright 1998, Rogue Wave Software, Inc.

NAME

     stack

      - A container adapter that behaves like a stack  (last  in,
     first out).

SYNOPSIS

     #include <stack>
     template <class T, class Container = deque<T> >
     class stack ;

DESCRIPTION

     The stack container adapter causes  a  container  to  behave
     like a "last in, first out" (LIFO) stack. The last item that
     was put ("pushed") onto the stack is the first item  removed
     ("popped"  off).  The  stack can adapt to any container that
     includes the operations back(), push_back(), and pop_back().
     In particular, deque, list, and vector can be used.

INTERFACE

     template <class T, class Container = deque<T> >
     class stack {
     public:
     // typedefs
     typedef typename Container::value_type value_type;
     typedef typename Container::size_type size_type;
     typedef Container container_type;
     // Construct
     explicit stack (const Container& = Container());
     // Accessors
     bool empty () const;
     size_type size () const;
     value_type& top ();
     const value_type& top () const;
     void push (const value_type&);
     void pop ();
     };

     // Non-member Operators
     template <class T, class Container>
     bool operator== (const stack<T, Container>&,
     const stack<T, Container>&);
     template <class T, class Container>
     bool operator!= (const stack<T, Container>&,
     const stack<T, Container>&);
     template <class T, class Container>
     bool operator< (const stack<T, Container>&,
     const stack<T, Container>&);
     template <class T, class Container>
     bool operator> (const stack<T, Container>&,
     const stack<T, Container>&);
     template <class T, class Container>
     bool operator<= (const stack<T, Container>&,
     const stack<T, Container>&);
     template <class T, class Container>
     bool operator>= (const stack<T, Container>&,
     const stack<T, Container>&);

CONSTRUCTORS

     explicit
     stack(const Container& = Container());


        Constructs an empty stack. The stack uses  the  allocator
        alloc for all storage management.

MEMBER FUNCTIONS

     bool
     empty() const;


        Returns true if the stack is empty, otherwise false.



     void
     pop();


        Removes the item at the top of the stack.



     void
     push(const value_type& x);


        Pushes x onto the stack.



     size_type
     size() const;


        Returns the number of elements on the stack.



     value_type&
     top();


        Returns a reference to the item at the top of the  stack.
        This  is the last item pushed onto the stack unless pop()
        has been called since then.



     const value_type&
     top() const;


        Returns a constant reference to the item at  the  top  of
        the stack as a const value_type.

NON-MEMBER OPERATORS

     template <class T, class Container>
     bool operator==(const stack<T, Container>& x,
     const stack<T, Container>& y);


        Returns true if x is the same as y.



     template <class T, class Container>
     bool operator!=(const stack<T, Container>& x,
     const stack<T, Container>& y);


        Returns !(x==y).

     template <class T, class Container>
     bool operator<(const stack<T, Container>& x,
     const stack<T, Container>& y);


        Returns true if the stack defined by  the  elements  con-
        tained  in  x  is  lexicographically  less than the stack
        defined by the elements of y.



     template <class T, class Container>
     bool operator>(const stack<T, Container>& x,
     const stack<T, Container>& y);


        Returns y < x.



     template <class T, class Container>
     bool operator<=(const stack<T, Container>& x,
     const stack<T, Container>& y);


        Returns !(y < x).



     template <class T, class Container>
     bool operator>=(const stack<T, Container>& x,
     const stack<T, Container>& y);


        Returns !(x < y).

EXAMPLE

     //
     // stack.cpp
     //
     #include <stack>
     #include <vector>
     #include <deque>
     #include <string>
     #include <iostream>
     using namespace std;

     int main(void)
      {
     // Make a stack using a vector container
     stack<int,vector<int> > s;
     // Push a couple of values on the stack
     s.push(1);
     s.push(2);
     cout << s.top() << endl;

     // Now pop them off
     s.pop();
     cout << s.top() << endl;
     s.pop();

     // Make a stack of strings using a deque
     stack<string,deque<string> > ss;
     // Push a bunch of strings on then pop them off
     int i;
     for (i = 0; i < 10; i++)
        {
        ss.push(string(i+1,'a'));
        cout << ss.top() << endl;
        }
     for (i = 0; i < 10; i++)
        {
        cout << ss.top() << endl;
        ss.pop();
        }

     return 0;
      }

     Program Output




     2
     1
     a
     aa
     aaa
     aaaa
     aaaaa
     aaaaaa
     aaaaaaa
     aaaaaaaa
     aaaaaaaaa
     aaaaaaaaaa
     aaaaaaaaaa
     aaaaaaaaa
     aaaaaaaa
     aaaaaaa
     aaaaaa
     aaaaa
     aaaa
     aaa
     aa
     a

WARNINGS

     If  your  compiler  does  not  support  template   parameter
     defaults,  you  are  required to supply a template parameter
     for Container. For example:

     You would not be able to write,

     stack<int> var;

     Instead, you would have to write,

     stack<int, deque<int> > var;

     If your compiler does not support namespaces,  then  you  do
     not need the using declaration for std.

SEE ALSO

     allocator, Containers, deque, list, vector