fstream in("...",ios::in);
fstream out("...".ios::out);
char *s=new char[...];
in.getline(s,100,'\n');

#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;
}