C++ Programming. String Check for the valid pair of brackets.

// implementation file for a stack class

#include <iostream>
using namespace std;

const int stack_size = 1000;

class stack
{
      private:
         // data for the stack
         char data [stack_size];
         // the index of the top element of the stack
         int top;
      public:
         stack ();   // constructor creates an empty stack
         void push (char item);  // puts item on the top of the stack
         char pop ();   // removes and returns the item at the top of stack
         bool empty ();
         bool full ();
};

// initialize the stack to an empty stack
stack::stack ()
{
   top = -1;
}

// push adds a new element to the top of the stack
void stack::push (char item)
{
     // if the stack is full, error
     if (full ())
     {
        cout << "\n\nStack Error: pushing on a full stack";
        cout << "\nThe item being pushed is " << item;
     }
     else  // OK to add the element
     {
           top++;
           data [top] = item;
     }
}

// pop removes and returns the top element of the stack
char stack::pop ()
{
     // if the stack is empty, error
     if (empty ())
     {
        cout << "\n\nStack Error: Popping an empty stack";
        cout << "\nReturing a ?";
        return '?';
     } 
     else // OK to pop
     {
          top--;
          return data [top + 1];
     }
}

// empty returns true if the stack is empty, else it returns false
bool stack::empty ()
{
     return top == -1;
}

// full returns true if the stack is full, else it returns false
bool stack::full ()
{
     return top == stack_size - 1;
}

/*
  
  Program reads an expression terminated by an s, and tells whether the
  parentheses (), [], and {} match correctly or not
*/

#include <cstdlib>
#include <iostream>
#include "stack.h"

using namespace std;

int main(int argc, char *argv[])
{
    stack equation;  // stack of open parentheses
    char ch;         // current character
    char popped;     // an element popped off the stack
    bool good;       // true if everything matches
    
    good = true;
    
    cout << "Enter an equation followed by an s:\n";
    cin >> ch;
    
    // continue reading an processing characters until an s is read
    while (ch != 's')
    {
          // if it is an open parenthesis, put on the stack
          if (ch == '{' || ch == '[' || ch == '(')
          {
                 equation.push (ch);
          }
          else
          // if it is a close parenthesis, pop the stack and match
          if (ch == '}' || ch == ']' || ch == ')')
          {
                 // stuff on the stack, ok to pop
                 if (! equation.empty ())
                 {
                    popped = equation.pop ();
                    // if the characters don't match
                    if (! (popped == '{' && ch == '}' ||
                        popped == '[' && ch == ']' ||
                            popped == '(' && ch == ')'))
                    good = false;
                 }
                 else // nothing on the stack
                      good = false;
          }
          cin >> ch;
    }
    if (good && equation.empty ())
       cout << "\n\nYes, it matched";
    else
        cout << "\n\nNo, it was bad!";
    
    
    cout << "\n\n";
    
    system("PAUSE");
    return EXIT_SUCCESS;
}