栈实现符号平衡检测

检测{}[]()是否一一配对：

 

#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()
{
    string Openstr = "([{";
    string Closestr = ")]}";

    string code;
    cout << "输入代码:" << endl;
    cin >> code;

    Stack<char> stk;

    for ( string::size_type index = 0 ; index != code.size() ; ++index )    //遍历代码
        for ( string::size_type i = 0 ; i != Openstr.size() ; ++i ){
            if ( code[index] == Openstr[i] )                                //是开放符号则入栈
                stk.push( code[index] );
            if ( code[index] == Closestr[i] ){
                if ( stk.IsEmpty() ){                                       //遇到封闭符号栈空报错
                    cout << "error:" << code[index] << "找不到匹配的符号" << endl;
                    return -1;
                }
                if ( stk.pop() != Openstr[i] ){                             //弹出的值不是对应的符号
                    cout << "error:" << code[index] << "找不到匹配的符号" << endl;
                    return -1;
                }
            }
        }

    if ( stk.IsEmpty() )
        cout << "0 error" << endl;
    else
        cout << "error:" << stk.pop() << "找不到匹配的符号" << endl;

    return 0;
}