#include <vector>
using namespace std;

template <class T>
class Stack {
public:   //  Constructors, destructors and assignment operator
 Stack() { this->create(); }
 Stack( const Stack& s ) { copy( s ); }
 ~Stack() { delete v; }

 Stack& operator=( const Stack& s );

public:   //  Member functions and other operators
 bool empty() const;
 int size() const;

 void push( const T& t );
 T pop();
 void clear();

private:
 vector<T> * v;  //  Pointer to allocated vector

public:
 void create();
 void copy( const Stack<T>& s );
};

// create()
template <class T>
void Stack<T>::create()
{
 v = new vector<T>;
}

// copy()
template <class T>
void Stack<T>::copy( const Stack<T>& s )
{
 // v = s.v;    // copy all elements of s.v into v
 // v->operator=( s.v );   // this is the vector<T> operator=()

 vector<T> * p = s.v;  // p points to the vector in Stack s
 for ( int i = 0 ; i < s.size() ; i++ )
 {
//    v->push_back( p->operator[]( i ) );
//    v->push_back( (*p).operator[]( i ) );
   v->push_back( (*p)[i] );
 }
}


// operator=()
template <class T>
Stack<T>& Stack<T>::operator=( const Stack<T>& s )
{
 if ( this != &s )  // avoids   s1 = s1;
 {
   clear();
   copy( s );
 }

 return *this;
}

// empty()
template <class T>
bool Stack<T>::empty() const
{
//  return ( size() == 0 );

 if ( size() == 0 ) {
   return true;
 } else {
   return false;
 }
}

// size()
template <class T>
int Stack<T>::size() const
{
 return v->size();
}

// clear()
template <class T>
void Stack<T>::clear()
{
 v->clear();
//  while ( size() > 0 ) {
//    pop()  OR  v->pop_back()
//  }
}

// push()
template <class T>
void Stack<T>::push( const T& t )
{
 v->push_back( t );
}

// pop()
template <class T>
T Stack<T>::pop()
{
 T temp = v->operator[]( v->size() - 1 );  // get the last element
 v->pop_back();
 return temp;
}