I need help fixing my compiling errors. Here\'s the assignment: https://www.drop
ID: 3706286 • Letter: I
Question
I need help fixing my compiling errors.
Here's the assignment: https://www.dropbox.com/s/mawyte4ivhadipw/CSC260_P5-Palindrone_StacksQueues.pdf?dl=0
//Stack.h
#ifndef STACK_H
#define STACK_H
#include <iostream>
using namespace std;
// Stack template
template <class T>
class Stack
{
private:
T *stackArray;
int stackSize;
int top;
public:
//Constructor
Stack(int);
// Copy constructor
Stack(const Stack&);
// Destructor
~Stack();
// Stack operations
void push(T);
void pop(T &);
bool isFull();
bool isEmpty();
};
//***************************************************
// Constructor *
//***************************************************
template <class T>
Stack<T>::Stack(int size)
{
stackArray = new T[size];
stackSize = size;
top = -1;
}
//***************************************************
// Copy constructor *
//***************************************************
template <class T>
Stack<T>::Stack(const Stack &obj)
{
// Create the stack array.
if (obj.stackSize > 0)
stackArray = new T[obj.stackSize];
else
stackArray = NULL;
// Copy the stackSize attribute.
stackSize = obj.stackSize;
// Copy the stack contents.
for (int count = 0; count < stackSize; count++)
stackArray[count] = obj.stackArray[count];
// Set the top of the stack.
top = obj.top;
}
//***************************************************
// Destructor *
//***************************************************
template <class T>
Stack<T>::~Stack()
{
if (stackSize > 0)
delete [] stackArray;
}
//*************************************************************
// Member function push pushes the argument onto *
// the stack. *
//*************************************************************
template <class T>
void Stack<T>::push(T item)
{
if (isFull())
{
cout << "The stack is full. ";
}
else
{
top++;
stackArray[top] = item;
}
}
//*************************************************************
// Member function pop pops the value at the top *
// of the stack off, and copies it into the variable *
// passed as an argument. *
//*************************************************************
template <class T>
void Stack<T>::pop(T &item)
{
if (isEmpty())
{
cout << "The stack is empty. ";
}
else
{
item = stackArray[top];
top--;
}
}
//*************************************************************
// Member function isFull returns true if the stack *
// is full, or false otherwise. *
//*************************************************************
template <class T>
bool Stack<T>::isFull()
{
bool status;
if (top == stackSize - 1)
status = true;
else
status = false;
return status;
}
//*************************************************************
// Member function isEmpty returns true if the stack *
// is empty, or false otherwise. *
//*************************************************************
template <class T>
bool Stack<T>::isEmpty()
{
bool status;
if (top == -1)
status = true;
else
status = false;
return status;
}
#endif
//Queue.h
#ifndef QUEUE_H
#define QUEUE_H
#include <iostream>
using namespace std;
// Stack template
template <class T>
class Queue
{
private:
T *queueArray; // Points to the queue array
int queueSize; // The queue size
int front; // Subscript of the queue front
int rear; // Subscript of the queue rear
int numItems; // Number of items in the queue
public:
// Constructor
Queue(int);
// Copy constructor
Queue(const Queue &);
// Destructor
~Queue();
// Queue operations
void enqueue(T);
void dequeue(T &);
bool isEmpty() const;
bool isFull() const;
void clear();
};
//***************************************************************
// This constructor creates an empty queue of a specified size. *
//***************************************************************
template <class T>
Queue<T>::Queue(int s)
{
queueArray = new T[s];
queueSize = s;
front = -1;
rear = -1;
numItems = 0;
}
//***************************************************************
// Copy constructor *
//***************************************************************
template <class T>
Queue<T>::Queue(const Queue &obj)
{
// Allocate the queue array.
queueArray = new T[obj.queueSize];
// Copy the other object's attributes.
queueSize = obj.queueSize;
front = obj.front;
rear = obj.rear;
numItems = obj.numItems;
// Copy the other object's queue array.
for (int count = 0; count < obj.queueSize; count++)
queueArray[count] = obj.queueArray[count];
}
//***************************************************************
// Destructor *
//***************************************************************
template <class T>
Queue<T>::~Queue()
{
delete [] queueArray;
}
//***************************************************************
// Function enqueue inserts a value at the rear of the queue. *
//***************************************************************
template <class T>
void Queue<T>::enqueue(T item)
{
if (isFull())
cout << "The queue is full. ";
else
{
// Calculate the new rear position
rear = (rear + 1) % queueSize;
// Insert new item
queueArray[rear] = item;
// Update item count
numItems++;
}
}
//***************************************************************
// Function dequeue removes the value at the front of the queue *
// and copies t into num. *
//***************************************************************
template <class T>
void Queue<T>::dequeue(T &item)
{
if (isEmpty())
cout << "The queue is empty. ";
else
{
// Move front
front = (front + 1) % queueSize;
// Retrieve the front item
item = queueArray[front];
// Update item count
numItems--;
}
}
//***************************************************************
// isEmpty returns true if the queue is empty, otherwise false. *
//***************************************************************
template <class T>
bool Queue<T>::isEmpty() const
{
bool status;
if (numItems)
status = false;
else
status = true;
return status;
}
//***************************************************************
// isFull returns true if the queue is full, otherwise false. *
//***************************************************************
template <class T>
bool Queue<T>::isFull() const
{
bool status;
if (numItems < queueSize)
status = false;
else
status = true;
return status;
}
//*****************************************************************
// clear sets the front and rear indices, and sets numItems to 0. *
//*****************************************************************
template <class T>
void Queue<T>::clear()
{
front = queueSize - 1;
rear = queueSize - 1;
numItems = 0;
}
#endif
/Palindrome.h
#ifndef _PALINDROME
#define _PALINDROME
// method protocol declaration
int isPalindrome(char *isPl);
#endif
//Palindrome.cpp
#include "Palindrome.h"
#include "stackh"
#include "queue.h"
// method to check the input is palindrome or not
int isPalindrome(char *isPl)
{
// declare the required variables
int lp = 0;
stack palstk;
queue palqu;
// code to check the palindrome
while( isPl[lp] != '' )
{
if(isalpha(isPl[lp]))
{
palstk.push(toupper(isPl[lp]));
palqu.push(toupper(isPl[lp]));
}
lp++;
}
while(!palstk.empty())
{
if(palqu.front()==palstk.top())
{
palqu.pop();
palstk.pop();
}else
{
return 0;
}
}
return 1;
}
//main.cpp
#include "Palindrome.h"
#include <stdio.h>
// main method to invoke the functions to test palindrome
int main()
{
//Character array with a set of strings
char *palcheck[] = {
"Hello world", "A dog, a panic in a pagoda",
"A dog, a plan, a canal, pagoda",
"A man, a plan, a canal?? Panama!",
"civic",
"No lemons, no melon",
"racecar",
"RACEcar",
"Rats live on no evil star.",
"Red rum, sir, is murder!",
"Rise to vote, sir.",
"rotator",
};
// loop code to check each string is palindrome or not
for(int lp=0;lp<12;lp++)
{
printf("%s:",palcheck[lp]);
printf("%s ",isPalindrome(palcheck[lp])?printf("yes")
: printf("no"));
}
}
Explanation / Answer
Please find the error free code below.
CODE
======================
Stack.h
*******************************
#ifndef STACK_H
#define STACK_H
#include <iostream>
using namespace std;
// Stack template
template <class T>
class Stack
{
public:
T *stackArray;
int stackSize;
int top;
//Constructor
Stack(int);
// Copy constructor
Stack(const Stack&);
// Destructor
~Stack();
// Stack operations
void push(T);
T pop();
bool isFull();
bool isEmpty();
};
//***************************************************
// Constructor *
//***************************************************
template <class T>
Stack<T>::Stack(int size)
{
stackArray = new T[size];
stackSize = size;
top = -1;
}
//***************************************************
// Copy constructor *
//***************************************************
template <class T>
Stack<T>::Stack(const Stack &obj)
{
// Create the stack array.
if (obj.stackSize > 0)
stackArray = new T[obj.stackSize];
else
stackArray = NULL;
// Copy the stackSize attribute.
stackSize = obj.stackSize;
// Copy the stack contents.
for (int count = 0; count < stackSize; count++)
stackArray[count] = obj.stackArray[count];
// Set the top of the stack.
top = obj.top;
}
//***************************************************
// Destructor *
//***************************************************
template <class T>
Stack<T>::~Stack()
{
if (stackSize > 0)
delete [] stackArray;
}
//*************************************************************
// Member function push pushes the argument onto *
// the stack. *
//*************************************************************
template <class T>
void Stack<T>::push(T item)
{
if (isFull())
{
cout << "The stack is full. ";
}
else
{
top++;
stackArray[top] = item;
}
}
//*************************************************************
// Member function pop pops the value at the top *
// of the stack off, and copies it into the variable *
// passed as an argument. *
//*************************************************************
template <class T>
T Stack<T>::pop()
{
if (isEmpty())
{
cout << "The stack is empty. ";
return '';
}
else
{
T item = stackArray[top];
top--;
return item;
}
}
//*************************************************************
// Member function isFull returns true if the stack *
// is full, or false otherwise. *
//*************************************************************
template <class T>
bool Stack<T>::isFull()
{
bool status;
if (top == stackSize - 1)
status = true;
else
status = false;
return status;
}
//*************************************************************
// Member function isEmpty returns true if the stack *
// is empty, or false otherwise. *
//*************************************************************
template <class T>
bool Stack<T>::isEmpty()
{
bool status;
if (top == -1)
status = true;
else
status = false;
return status;
}
#endif
Queue.h
*******************************
#ifndef QUEUE_H
#define QUEUE_H
#include <iostream>
using namespace std;
// Queue template
template <class T>
class Queue
{
public:
T *queueArray; // Points to the queue array
int queueSize; // The queue size
int front; // Subscript of the queue front
int rear; // Subscript of the queue rear
int numItems; // Number of items in the queue
// Constructor
Queue(int);
// Copy constructor
Queue(const Queue &);
// Destructor
~Queue();
// Queue operations
void enqueue(T);
T dequeue();
bool isEmpty() const;
bool isFull() const;
void clear();
};
//***************************************************************
// This constructor creates an empty queue of a specified size. *
//***************************************************************
template <class T>
Queue<T>::Queue(int s)
{
queueArray = new T[s];
queueSize = s;
front = -1;
rear = -1;
numItems = 0;
}
//***************************************************************
// Copy constructor *
//***************************************************************
template <class T>
Queue<T>::Queue(const Queue &obj)
{
// Allocate the queue array.
queueArray = new T[obj.queueSize];
// Copy the other object's attributes.
queueSize = obj.queueSize;
front = obj.front;
rear = obj.rear;
numItems = obj.numItems;
// Copy the other object's queue array.
for (int count = 0; count < obj.queueSize; count++)
queueArray[count] = obj.queueArray[count];
}
//***************************************************************
// Destructor *
//***************************************************************
template <class T>
Queue<T>::~Queue()
{
delete [] queueArray;
}
//***************************************************************
// Function enqueue inserts a value at the rear of the queue. *
//***************************************************************
template <class T>
void Queue<T>::enqueue(T item)
{
if (isFull())
cout << "The queue is full. ";
else
{
// Calculate the new rear position
rear = (rear + 1) % queueSize;
// Insert new item
queueArray[rear] = item;
// Update item count
numItems++;
}
}
//***************************************************************
// Function dequeue removes the value at the front of the queue *
// and copies t into num. *
//***************************************************************
template <class T>
T Queue<T>::dequeue()
{
if (isEmpty()) {
cout << "The queue is empty. ";
return '';
}
else
{
// Move front
front = (front + 1) % queueSize;
// Retrieve the front item
T item = queueArray[front];
// Update item count
numItems--;
return item;
}
}
//***************************************************************
// isEmpty returns true if the queue is empty, otherwise false. *
//***************************************************************
template <class T>
bool Queue<T>::isEmpty() const
{
bool status;
if (numItems)
status = false;
else
status = true;
return status;
}
//***************************************************************
// isFull returns true if the queue is full, otherwise false. *
//***************************************************************
template <class T>
bool Queue<T>::isFull() const
{
bool status;
if (numItems < queueSize)
status = false;
else
status = true;
return status;
}
//*****************************************************************
// clear sets the front and rear indices, and sets numItems to 0. *
//*****************************************************************
template <class T>
void Queue<T>::clear()
{
front = queueSize - 1;
rear = queueSize - 1;
numItems = 0;
}
#endif
Palindrome.h
*******************************
#ifndef _PALINDROME
#define _PALINDROME
// method protocol declaration
int isPalindrome(char *isPl);
#endif
Palindrome.cpp
*******************************
#include "Palindrome.h"
#include "Stack.h"
#include "Queue.h"
// method to check the input is palindrome or not
int isPalindrome(char *isPl)
{
// declare the required variables
int lp = 0;
Stack<char> palstk(100);
Queue<char> palqu(100);
// code to check the palindrome
while( isPl[lp] != '' )
{
if(isalpha(isPl[lp]))
{
palstk.push(toupper(isPl[lp]));
palqu.enqueue(toupper(isPl[lp]));
}
lp++;
}
while(!palstk.isEmpty())
{
if(palqu.front==palstk.top)
{
palqu.dequeue();
palstk.pop();
}else
{
return 0;
}
}
return 1;
}
Main.cpp
*******************************
#include "Palindrome.cpp"
#include <cstdio>
// main method to invoke the functions to test palindrome
int main()
{
//Character array with a set of strings
char *palcheck[] = {
"Hello world", "A dog, a panic in a pagoda",
"A dog, a plan, a canal, pagoda",
"A man, a plan, a canal?? Panama!",
"civic",
"No lemons, no melon",
"racecar",
"RACEcar",
"Rats live on no evil star.",
"Red rum, sir, is murder!",
"Rise to vote, sir.",
"rotator",
};
// loop code to check each string is palindrome or not
for(int lp=0;lp<12;lp++)
{
printf("%s:",palcheck[lp]);
printf("%s ",isPalindrome(palcheck[lp])?printf("yes")
: printf("no"));
}
}
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.