以下是实现以及应用的一个例程:

 

#include <iostream>

using namespace std;

template <typename Object>
class Vector
{
    public:
        explicit Vector( int initSize = 0 )
        : theSize( initSize ),theCapacity( initSize + SPARE_CAPACITY )
        { objects = new Object[ theCapacity ]; }
        Vector( const Vector &rhs ) : objects( NULL )               //三大函数
        { operator=( rhs ); }
        ~Vector()
        { delete [] objects; }

        const Vector &operator=( const Vector &rhs )
        {
            if ( this != &rhs ){
                delete [] objects;
                theSize = rhs.size();
                theCapacity = rhs.theCapacity;

                objects = new Object[ capacity() ];
                for ( int k = 0 ; k < size() ; k++ )
                    objects[k] = rhs.objects[k];
            }

            return *this;
        }

        void resize( int newSize )                                  //重设大小
        {
            if ( newSize > theCapacity )
                reserve( newSize * 2 + 1 );
            theSize = newSize;
        }

        void reserve( int newCapacity )
        {
            if ( newCapacity < theSize )
                return ;

            Object *OldArray = objects;

            objects = new Object[ newCapacity ];
            for ( int k = 0 ; k < theSize ; k++ )
                objects[k] = OldArray[k];

            theCapacity = newCapacity;

            delete [] OldArray;
        }

        Object &operator[]( int index )                             //下标引用
        { return objects[ index ]; }
        const Object &operator[]( int index ) const
        { return objects[ index ]; }

        bool empty() const
        { return size() == 0; }

        int size() const
        { return theSize; }
        int capacity() const
        { return theCapacity; }

        void push_back( const Object &x )
        {
            if ( theSize == theCapacity )
                reserve( 2 * theCapacity + 1 );
            objects[theSize++] = x;
        }

        void pop_back()
        { theSize--; }

        const Object &back() const
        { return objects[theSize-1]; }

        typedef Object *iterator;
        typedef const Object *const_iterator;

        iterator begin()
        { return &objects[0]; }
        const_iterator begin() const
        { return &objects[0]; }
        iterator end()
        { return &objects[ size() ]; }
        const_iterator end() const
        { return &objects[ size() ]; }

        enum { SPARE_CAPACITY = 16 };

    private:
        int theSize;
        int theCapacity;
        Object *objects;
};

template <typename element>
class Stack
{
    public:
       Stack() : theArray( Vector<element>() ) //构造函数
       { topOfStack = -1; }

       void push( element &x )                                                //入栈
       {
           theArray.push_back( x );
           topOfStack++;
       }

       const element &pop()                                                          //出栈
       {
           topOfStack--;
           const element &last = theArray.back();
           theArray.pop_back();

           return last;
       }

        bool IsEmpty()
        { return topOfStack == -1; }

    private:
        Vector<element> theArray;
        int topOfStack;
};

int main()
{
    Stack<int> Num;

    cout << "入栈一组数据" << endl;

    int temp;
    while ( cin >> temp )
        Num.push( temp );

    cout << "出栈:" << endl;
    while ( !Num.IsEmpty() )
        cout << Num.pop() << endl;

    return 0;
}