Top of document
©Copyright 1999 Rogue Wave Software

stack


     Container Adaptor

Summary

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

Contents

Synopsis

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

Description

The stack container adaptor 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.

Interface

template <class T, class Container = deque<T>,
          class Allocator = allocator>
 class stack {
public:
// typedefs
   typedef typename Container::value_type value_type;
   typedef typename Container::size_type size_type;
   typedef Allocator allocator_type
// Construct
   explicit stack (const Allocator& = Allocator());
   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, class Allocator>
 bool operator== (const stack<T, Container, Allocator>&, 
                  const stack<T, Container, Allocator>&);
template <class T, class Container, class Allocator>
 bool operator< (const stack<T, Container, Allocator>&, 
                 const stack<T, Container, Allocator>&);

Constructor

explicit
stack (const Allocator& alloc = Allocator());

Allocator

allocator_type get_allocator () const;

Member Functions

bool 
empty () const;
void 
pop ();
void 
push (const value_type& x);
size_type 
size () const;
value_type& 
top ();
const value_type& 
top () const;

Non-member Operators

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

Example

//
// 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>, allocator> 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>, allocator> 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

Warnings

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

You would not be able to write,

stack<int> var;

Instead, you would have to write,

stack<int, deque<int>, allocator> var;

See Also

allocator, Containers, deque, list, vector


Top of document