Fstream Palindrome check

#include<iostream> 
#include <cstdlib> // For EXIT_FAILURE and EXIT_SUCCESS 
#include <fstream> 
#include<string> 
using namespace std; 
const int MAX=50;	// initialize max string size of 50 characters 
typedef char StackElement;  // define StackElement 
typedef char QueueElement;  // define QueueElement 
class Stack 
{ 
public: 
   Stack(){top=-1;arr[MAX]=0;}   // default stack constructor 
	  void push(StackElement & ch);  // push function 
	  StackElement topNpop();		 // top and pop functions combined 
	  bool empty() const;			// empty function 
private: 
	  StackElement arr[MAX];	// define char array 
	  int   top;				  // define int top 
	
}; 
/******************************************* 
FUNCTION: push() 
DESCRIPTION: Pushes an element onto the stack 
PRECONDITION: Waiting for function call 
POSTCONTION: New element character on top of stack 
*******************************************/ 
inline void Stack::push(StackElement & ch) 
{ 
   if(top<MAX) 
   { 
	  top++;		  // increment top 
	  arr[top]=ch;  // push onto stack 
   } 
   else 
   { 
	  cout<<"Stack is full.\n";  // display stack is full 
   } 


} 
/******************************************* 
FUNCTION: topNpop() 
DESCRIPTION: Reads and pops top element off the stack 
PRECONDIION: Waiting for function call 
POSTCONDITION:  One element read and removed fromt he stack 
RETURN: Top element from stack 
********************************************/ 

inline StackElement Stack::topNpop() 
{ 
   if(top>-1) 
   { 
	  return(arr[top]);  // returns top element 
	  top--;			// remove froms stack 
   } 
   else 
   { 
	  cout<<"Stack is empty.\n";  // display stack is empty 
	  return(0); 

   } 

} 
/******************************************* 
FUNCTION: empty() 
DESCRIPTION: returns result value if stack is empty 
PRECONDITION: result=false 
POSTCONDITION: result may be true or remain false 
RETURN: result if true or false 
********************************************/		  
inline bool Stack::empty() const 
{ 
   bool result=false;   // initialize bool as false 
   if (top==-1)		  
   { 
	  result=true;		// if top is -1 return result true 
	  return(result); 
   } 
   else 
   { 
	  return(result);	 // else return false 
   } 
} 
class Queue						   // Queue class 
{ 
public: 
	  Queue(){front=0, back=0;arr[MAX]=0;}   // Queue default constructor 
	  void addq(QueueElement & ch);		  // define addq 
	  QueueElement frontNremoveq();		 // define frontNremove 
private: 
	  QueueElement arr[MAX];			// initialize QueueElement array 
	  int front, back;				  // initialize int front and back 
	
}; 
/******************************************* 
FUNCTION: addq() 
DESCRIPTION: adds an element onto the queue 
PRECONDITION: Waiting for element to add 
POSTCONDITION: New element now on the queue 
********************************************/ 
inline void Queue::addq(QueueElement &ch) 
{ 
   if(front!=(back+1)%MAX) 
   { 
	  arr[back]=ch;	 // add element to back of queue 
	  back=(back+1)%MAX; 
   } 
   else 
   { 
	  cerr<<"Error Queue is full\n";  // display queue is full 
   } 
} 
/******************************************* 
FUNCTION: frontNremoveq() 
DESCRIPTION: reads and removes front element from queue 
PRECONDITION: front pointing to front of queue 
POSTCONDITION: front element is returned and then incremented 
********************************************/ 
inline QueueElement Queue::frontNremoveq() 
{ 
   if(front!=back) 
   { 
	  return(arr[front]);	// return front element 
	  front++;			// remove front element 
   } 
   else 
   { 
	  cout<<"Queue is empty.\n";  // display queue is empty 
	  return(0); 
   } 
} 

/***************************MAIN*******************  ***********/ 
int main() 
{ 
   Stack S;   // initialize stack 
   Queue Q;   // initialize queue 
string s; 
   int i=0;   // initialze int 'i' 
   char string[MAX];  // initialize char string 
   bool RESULT=false;  // initilize bool RESULT to false 
	

  
ifstream inside ("palindromeinput.txt"); 
  if (! inside.is_open()) 
  { cout << "Error opening file"; exit (1); } 

  while (! inside.eof() ) 
  { 
	inside.getline (string,100); 
	cout << string << endl; 
  } 

while(string[i]!=NULL) 
   { 
	  S.push(string[i]);  // push chars individually from string to 
	  Q.addq(string[i]);	  // stack and queue 
	  i++;	  // next char 
   } 
   while(i>0) 
   { 
	  if(S.topNpop()==Q.frontNremoveq())  // compare each element from 
	  {							  // stack and queue 
		 RESULT=true;  // if same for all chars return true 
	  } 
	  else 
	  { 
		 RESULT=false;  // if not same for any char break and return false 
		 break; 
	  } 
	  i--; 
   }	


if(RESULT==true) 
   { 
	  cout<<string<<" is a palindrome\n";  // display if true 
   } 
   else 
   { 
	  cout<<string<<" is not a palindrome\n"; // display if false 
   } 
	


ofstream outside ("palindromeoutput.txt"); 
  if (outside.is_open()) 
  { 
  
	outside << string; 
	outside<< string; 
	outside.close(); 
  } 
  return 0; 
}