stack(3C++) - stack(3C++)
Standard C++ Library Copyright 1998, Rogue Wave Software, Inc.
NAMEstack
- 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 stor‐
age management.
MEMBER FUNCTIONS
bool
empty() const;
Returns true if the stack is empty, otherwise false.
voidpop();
Removes the item at the top of the stack.
voidpush(const value_type& x);
Pushes x onto the stack.
size_typesize() 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 contained in x is lexico‐
graphically 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 stacks.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 Output21aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaWARNINGS
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
Rogue Wave Software 02 Apr 1998 stack(3C++)
