stack

Container Adapter

• Summary
• Data Type and Member Function Indexes
• Synopsis
• Description
• Interface
• Constructor
• Allocator
• Member Functions
• Non-member Operators
• Example
• Warnings
• See Also

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

Member Functions
empty() get_allocator() operator!=() operator<() operator<=() operator==() ()">operator>() =()">operator>=() pop() push()	size() top()

#include <stack>

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

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 provides the operations, back(), push_back(), and pop_back(). In particular, deque , list , and vector can be used.

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 typename Container::allocator_type allocator_type

// Construct

   explicit stack (const allocator_type& = allocator_type());
   allocator_type get_allocator () const;

// 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>&);

explicit
stack(const allocator_type& alloc = allocator_taype());

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

allocator_type 
get_allocator() const;

Returns a copy of the allocator used by self for storage management.

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 will be 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.

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

Equality operator. 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);

Inequality operator. 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 contained 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).

//
// stack.cpp
//
 #include <stack>
 #include <vector>
 #include <deque>
 #include <string>
 #include <iostream.h>

 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;
 }
Output :
2
1
a
aa
aaa
aaaa
aaaaa
aaaaaa
aaaaaaa
aaaaaaaa
aaaaaaaaa
aaaaaaaaaa
aaaaaaaaaa
aaaaaaaaa
aaaaaaaa
aaaaaaa
aaaaaa
aaaaa
aaaa
aaa
aa
a

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;

allocator, Containers, deque, list, vector

©Copyright 1996, Rogue Wave Software, Inc.