Answer to Question #40838 in C++ for melvin

Question

2.1. What is the effect of the following statements? If a statement is invalid, explain why it is invalid. The classes stackADT, stackType, and linkedStackType are as defined in this chapter.
2.1.1. stackADT<int> newStack;
2.1.2. stackType<double> sales(-10);
2.1.3. stackType<string> names;
2.1.4. linkedStackType<int> numStack(50);
2.2. Write a program that reads a line of text, changes each uppercase letter to lowercase, and places each letter both in a queue and onto a stack. The program should then verify whether the line of text is a palindrome (a set of letters or numbers that is the same whether read forward or backward).

Answer 1

#include "Queue.h"
#include "Stack.h"

/***************************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
strcpy(string," ");
cout << "Please enter a line of text: " << endl;
cin.getline (string,100);
for( int j = 0; j < s.size(); ++j)
{
if(s[j] >= 'A' && s[j] <= 'Z')
s += (s[j] | 32);
else
if(s[j] >= 'a' && s[j] <= 'z')
s += (s[j] & (~32));
else
s += s[j];
}
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<<" \nThis is a palindrome\n"; // display if true
}
else
{
cout<<string<<" \nThis is not a palindrome\n"; // display if false
}


system("pause");
return 0;
}

#ifndef _Queue_h
#define _Queue_h
#include <cstdlib> // For EXIT_FAILURE and EXIT_SUCCESS
#include <fstream>
#include <string>
#include <algorithm>
#include <iomanip>
#include <cctype>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
#include <iostream>

const int MAX=50; // initialize max string size of 50 characters
typedef char QueueElement; // define QueueElement
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);
}
}
#endif

#ifndef _Stack_h
#define _Stack_h
#include "Queue.h"

// initialize max string size of 50 characters
typedef char StackElement; // define StackElement
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
}
}
#endif