Code for Question #1: #include <iostream> #include <cassert> using namespace std
ID: 3702089 • Letter: C
Question
Code for Question #1:
#include <iostream>
#include <cassert>
using namespace std;
template <class Type>
class stackADT
{
public:
virtual void initializeStack() = 0;
//Method to initialize the stack to an empty state.
//Postcondition: Stack is empty
virtual bool isEmptyStack() const = 0;
//Function to determine whether the stack is empty.
//Postcondition: Returns true if the stack is empty,
// otherwise returns false.
virtual bool isFullStack() const = 0;
//Function to determine whether the stack is full.
//Postcondition: Returns true if the stack is full,
// otherwise returns false.
virtual void push(const Type& newItem) = 0;
//Function to add newItem to the stack.
//Precondition: The stack exists and is not full.
//Postcondition: The stack is changed and newItem
// is added to the top of the stack.
virtual Type top() const = 0;
//Function to return the top element of the stack.
//Precondition: The stack exists and is not empty.
//Postcondition: If the stack is empty, the program
// terminates; otherwise, the top element
// of the stack is returned.
virtual void pop() = 0;
//Function to remove the top element of the stack.
//Precondition: The stack exists and is not empty.
//Postcondition: The stack is changed and the top
// element is removed from the stack.
};
// -- stackType -------------------
template <class Type>
class stackType: public stackADT<Type>
{
public:
const stackType<Type>& operator=(const stackType<Type>&);
//Overload the assignment operator.
void initializeStack();
//Function to initialize the stack to an empty state.
//Postcondition: stackTop = 0
bool isEmptyStack() const;
//Function to determine whether the stack is empty.
//Postcondition: Returns true if the stack is empty,
// otherwise returns false.
bool isFullStack() const;
//Function to determine whether the stack is full.
//Postcondition: Returns true if the stack is full,
// otherwise returns false.
void push(const Type& newItem);
//Function to add newItem to the stack.
//Precondition: The stack exists and is not full.
//Postcondition: The stack is changed and newItem
// is added to the top of the stack.
Type top() const;
//Function to return the top element of the stack.
//Precondition: The stack exists and is not empty.
//Postcondition: If the stack is empty, the program
// terminates; otherwise, the top element
// of the stack is returned.
void pop();
//Function to remove the top element of the stack.
//Precondition: The stack exists and is not empty.
//Postcondition: The stack is changed and the top
// element is removed from the stack.
stackType(int stackSize = 100);
//constructor
//Create an array of the size stackSize to hold
//the stack elements. The default stack size is 100.
//Postcondition: The variable list contains the base
// address of the array, stackTop = 0, and
// maxStackSize = stackSize.
stackType(const stackType<Type>& otherStack);
//copy constructor
~stackType();
//destructor
//Remove all the elements from the stack.
//Postcondition: The array (list) holding the stack
// elements is deleted.
bool operator==(const stackType<Type>& otherStack) const;
private:
int maxStackSize; //variable to store the maximum stack size
int stackTop; //variable to point to the top of the stack
Type *list; //pointer to the array that holds the
//stack elements
void copyStack(const stackType<Type>& otherStack);
//Function to make a copy of otherStack.
//Postcondition: A copy of otherStack is created and
// assigned to this stack.
};
template <class Type>
void stackType<Type>::initializeStack()
{
stackTop = 0;
}//end initializeStack
template <class Type>
bool stackType<Type>::isEmptyStack() const
{
return (stackTop == 0);
}//end isEmptyStack
template <class Type>
bool stackType<Type>::isFullStack() const
{
return (stackTop == maxStackSize);
} //end isFullStack
template <class Type>
void stackType<Type>::push(const Type& newItem)
{
if (!isFullStack())
{
list[stackTop] = newItem; //add newItem to the
//top of the stack
stackTop++; //increment stackTop
}
else
cout << "Cannot add to a full stack." << endl;
}//end push
template <class Type>
Type stackType<Type>::top() const
{
assert(stackTop != 0); //if stack is empty,
//terminate the program
return list[stackTop - 1]; //return the element of the
//stack indicated by
//stackTop - 1
}//end top
template <class Type>
void stackType<Type>::pop()
{
if (!isEmptyStack())
stackTop--; //decrement stackTop
else
cout << "Cannot remove from an empty stack." << endl;
}//end pop
template <class Type>
stackType<Type>::stackType(int stackSize)
{
if (stackSize <= 0)
{
cout << "Size of the array to hold the stack must "
<< "be positive." << endl;
cout << "Creating an array of size 100." << endl;
maxStackSize = 100;
}
else
maxStackSize = stackSize; //set the stack size to
//the value specified by
//the parameter stackSize
stackTop = 0; //set stackTop to 0
list = new Type[maxStackSize]; //create the array to
//hold the stack elements
}//end constructor
template <class Type>
stackType<Type>::~stackType() //destructor
{
delete [] list; //deallocate the memory occupied
//by the array
}//end destructor
template <class Type>
void stackType<Type>::copyStack
(const stackType<Type>& otherStack)
{
delete [] list;
maxStackSize = otherStack.maxStackSize;
stackTop = otherStack.stackTop;
list = new Type[maxStackSize];
//copy otherStack into this stack
for (int j = 0; j < stackTop; j++)
list[j] = otherStack.list[j];
} //end copyStack
template <class Type>
stackType<Type>::stackType(const stackType<Type>& otherStack)
{
list = nullptr;
copyStack(otherStack);
}//end copy constructor
template <class Type>
const stackType<Type>& stackType<Type>::operator=
(const stackType<Type>& otherStack)
{
if (this != &otherStack) //avoid self-copy
copyStack(otherStack);
return *this;
} //end operator=
template <class Type>
bool stackType<Type>::operator==
(const stackType<Type>&
otherStack) const
{
if (this == &otherStack)
return true; //same object being tested
else {
// test stackTop value
//return false if top value differs
if (stackTop != otherStack.stackTop)
return false;
//falls thru here if two stack has same length
//for loop
//return false if any value differs
for(int i = 0; i < stackTop;i++) {
if (list[i] != otherStack.list[i])
return false;
}
return true;
}
}
int main() {
stackType<int> stack1(50);
stackType<int> stack2(50);
stack1.initializeStack();
stack2.initializeStack();
stack1.push(23);
stack1.push(45);
stack1.push(38);
stack1.push(32);
stack2.push(23);
stack2.push(45);
stack2.push(38);
stack2.push(32);
if (stack1 == stack2)
cout << " EQUAL";
else
cout << " NOT equal";
cout << endl;
return 0;
}
Question #2:
Pageof 6
ZOOM
#include <iostream>
#include <cassert>
using namespace std;
template <class Type>
class stackADT
{
public:
virtual void initializeStack() = 0;
//Method to initialize the stack to an empty state.
//Postcondition: Stack is empty
virtual bool isEmptyStack() const = 0;
//Function to determine whether the stack is empty.
//Postcondition: Returns true if the stack is empty,
// otherwise returns false.
virtual bool isFullStack() const = 0;
//Function to determine whether the stack is full.
//Postcondition: Returns true if the stack is full,
// otherwise returns false.
virtual void push(const Type& newItem) = 0;
//Function to add newItem to the stack.
//Precondition: The stack exists and is not full.
//Postcondition: The stack is changed and newItem
// is added to the top of the stack.
virtual Type top() const = 0;
//Function to return the top element of the stack.
//Precondition: The stack exists and is not empty.
//Postcondition: If the stack is empty, the program
// terminates; otherwise, the top element
// of the stack is returned.
virtual void pop() = 0;
//Function to remove the top element of the stack.
//Precondition: The stack exists and is not empty.
//Postcondition: The stack is changed and the top
// element is removed from the stack.
};
//Definition of the node
template <class Type>
struct nodeType
{
Type info;
nodeType<Type> *link;
};
template <class Type>
class linkedStackType: public stackADT<Type>
{
public:
const linkedStackType<Type>& operator=
(const linkedStackType<Type>&);
//Overload the assignment operator.
bool isEmptyStack() const;
//Function to determine whether the stack is empty.
//Postcondition: Returns true if the stack is empty;
// otherwise returns false.
bool isFullStack() const;
//Function to determine whether the stack is full.
//Postcondition: Returns false.
void initializeStack();
//Function to initialize the stack to an empty state.
//Postcondition: The stack elements are removed;
// stackTop = nullptr;
void push(const Type& newItem);
//Function to add newItem to the stack.
//Precondition: The stack exists and is not full.
//Postcondition: The stack is changed and newItem
// is added to the top of the stack.
Type top() const;
//Function to return the top element of the stack.
//Precondition: The stack exists and is not empty.
//Postcondition: If the stack is empty, the program
// terminates; otherwise, the top
// element of the stack is returned.
void pop();
//Function to remove the top element of the stack.
//Precondition: The stack exists and is not empty.
//Postcondition: The stack is changed and the top
// element is removed from the stack.
linkedStackType();
//Default constructor
//Postcondition: stackTop = nullptr;
linkedStackType(const linkedStackType<Type>& otherStack);
//Copy constructor
~linkedStackType();
//Destructor
//Postcondition: All the elements of the stack are
// removed from the stack.
private:
nodeType<Type> *stackTop; //pointer to the stack
void copyStack(const linkedStackType<Type>& otherStack);
//Function to make a copy of otherStack.
//Postcondition: A copy of otherStack is created and
// assigned to this stack.
};
//Default constructor
template <class Type>
linkedStackType<Type>::linkedStackType()
{
stackTop = nullptr;
}
template <class Type>
bool linkedStackType<Type>::isEmptyStack() const
{
return(stackTop == nullptr);
} //end isEmptyStack
template <class Type>
bool linkedStackType<Type>:: isFullStack() const
{
return false;
} //end isFullStack
template <class Type>
void linkedStackType<Type>:: initializeStack()
{
nodeType<Type> *temp; //pointer to delete the node
while (stackTop != nullptr) //while there are elements in
//the stack
{
temp = stackTop; //set temp to point to the
//current node
stackTop = stackTop->link; //advance stackTop to the
//next node
delete temp; //deallocate memory occupied by temp
}
} //end initializeStack
template <class Type>
void linkedStackType<Type>::push(const Type& newElement)
{
nodeType<Type> *newNode; //pointer to create the new node
newNode = new nodeType<Type>; //create the node
newNode->info = newElement; //store newElement in the node
newNode->link = stackTop; //insert newNode before stackTop
stackTop = newNode; //set stackTop to point to the
//top node
} //end push
template <class Type>
Type linkedStackType<Type>::top() const
{
assert(stackTop != nullptr); //if stack is empty,
//terminate the program
return stackTop->info; //return the top element
}//end top
template <class Type>
void linkedStackType<Type>::pop()
{
nodeType<Type> *temp; //pointer to deallocate memory
if (stackTop != nullptr)
{
temp = stackTop; //set temp to point to the top node
stackTop = stackTop->link; //advance stackTop to the
//next node
delete temp; //delete the top node
}
else
cout << "Cannot remove from an empty stack." << endl;
}//end pop
template <class Type>
void linkedStackType<Type>::copyStack
(const linkedStackType<Type>& otherStack)
{
nodeType<Type> *newNode, *current, *last;
if (stackTop != nullptr) //if stack is nonempty, make it empty
initializeStack();
if (otherStack.stackTop == nullptr)
stackTop = nullptr;
else
{
current = otherStack.stackTop; //set current to point
//to the stack to be copied
//copy the stackTop element of the stack
stackTop = new nodeType<Type>; //create the node
stackTop->info = current->info; //copy the info
stackTop->link = nullptr; //set the link field of the
//node to nullptr
last = stackTop; //set last to point to the node
current = current->link; //set current to point to
//the next node
//copy the remaining stack
while (current != nullptr)
{
newNode = new nodeType<Type>;
newNode->info = current->info;
newNode->link = nullptr;
last->link = newNode;
last = newNode;
current = current->link;
}//end while
}//end else
} //end copyStack
//copy constructor
template <class Type>
linkedStackType<Type>::linkedStackType(
const linkedStackType<Type>& otherStack)
{
stackTop = nullptr;
copyStack(otherStack);
}//end copy constructor
//destructor
template <class Type>
linkedStackType<Type>::~linkedStackType()
{
initializeStack();
}//end destructor
//overloading the assignment operator
template <class Type>
const linkedStackType<Type>& linkedStackType<Type>::operator=
(const linkedStackType<Type>&
otherStack)
{
if (this != &otherStack) //avoid self-copy
copyStack(otherStack);
return *this;
}//end operator=
int main() {
linkedStackType<int> stack1;
//stack1.initializeStack();
stack1.push(23);
stack1.push(45);
stack1.push(38);
stack1.push(32);
while(!stack1.isEmptyStack()) {
cout << stack1.top() << " ";
stack1.pop();
}
cout << endl;
return 0;
}
Ouestion 1 Overload theoperator for the class stackType that returns true if two stacks of the same type are the same or returns false otherwise. Write test code to test your added functions nd implementation of the overload of-and source only the test code a also the output in Canvas Question 2 Repeat same work in Question 1 but this time for the linkedStackType that returns true if two stacks of the same type are the same or returns false otherwise. Write test code to test your added functions and source only the test code and implementation of the overload of also the output in CanvasExplanation / Answer
Hi, for the first question, the test code and overloading function are as follows with the output:
Question1:
template <class Type> bool stackType<Type>::operator== (const stackType<Type>& otherStack) const {
if (this == &otherStack)
return true; //same object being tested
else {
// test stackTop value
//return false if top value differs
if (stackTop != otherStack.stackTop)
return false;
//falls thru here if two stack has same length
//for loop
//return false if any value differs
for(int i = 0; i < stackTop;i++) {
if (list[i] != otherStack.list[i])
return false;
}
return true;
}
}
int main() {
stackType<int> stack1(50);
stackType<int> stack2(50);
stack1.initializeStack();
stack2.initializeStack();
stack1.push(23);
stack1.push(38);
stack1.push(32);
stack2.push(23);
stack2.push(45);
stack2.push(38);
stack2.push(32);
if (stack1 == stack2)
cout << " EQUAL";
else
cout << " NOT equal";
cout << endl;
return 0;
}
Here, in the test code, we have added 23.38.32 to stack1 and 23.45.38.32 to stack2. On comparing both the stacks, output is:
NOT equal
While on adding the same number of same elements in the same order e.g stack1=23.45.38.32 and stack2=23.45.38.32 outputs to:
EQUAL
Question2:
First of all, let's add the definition for the function == operator overloading:
1. Add to line 170 of your code,
bool operator==(const linkedStackType<Type>& otherStack) const;
2. Now to check if both stacks are of same size, I have added a count variable to count the number of elements in the stack.
For this, you have to add the following code:
a. At line 175, int count;
b. At line 196, count=0; // initializing the counter to 0
c. At line 262, count++; // incrementing the count on adding every element in method push()
d. At line 298, count--; // decrementing the count on removing every element in method pop()
3. Now add the definition of the function for overloading == operator as:
template <class Type> bool linkedStackType<Type>::operator== (const linkedStackType<Type>& otherStack) const {
if (this == &otherStack)
return true; //same object being tested
else {
// test count value
//return false if count value differs
if (count != otherStack.count) {
cout<<"Count is not same";
return false;
}
//falls thru here if two stacks have same length
//for loop
//return false if any value differs
nodeType<Type> *tempStack1, *tempStack2;
tempStack1 = stackTop; // temporary variable to store the node on stackTop for stack1
tempStack2 = otherStack.stackTop; // temporary variable to store the node on stackTop for stack2
for(int i = 0; i < count;i++) {
if (tempStack1->info != tempStack2->info)
return false;
tempStack1 = tempStack1->link; //pointing tempStack1 to its next node
tempStack2 = tempStack2->link; //pointing tempStack2 to its next node
}
return true;
}
}
4. main()
int main() {
linkedStackType < int >stack1;
linkedStackType < int >stack2;
stack1.initializeStack ();
stack2.initializeStack ();
stack1.push (23);
stack1.push (45);
stack1.push (38);
stack1.push (32);
stack2.push (23);
stack2.push (45);
stack2.push (38);
stack2.push (32);
if (stack1 == stack2)
cout << " EQUAL";
else
cout << " NOT equal";
cout << endl;
return 0;
}
Output: EQUAL
Now modifying main() a bit to check the different outputs:
Add stack1.pop() after stack2.push (32);
Output: Count is not same
Not equal
Also find follows the complete file for your reference. The code changes are in Bold. You can ask in case of any query.
Please rate if this solves your question :)
#include <iostream>
#include <cassert>
using namespace std;
template <class Type>
class stackADT
{
public:
virtual void initializeStack() = 0;
//Method to initialize the stack to an empty state.
//Postcondition: Stack is empty
virtual bool isEmptyStack() const = 0;
//Function to determine whether the stack is empty.
//Postcondition: Returns true if the stack is empty,
// otherwise returns false.
virtual bool isFullStack() const = 0;
//Function to determine whether the stack is full.
//Postcondition: Returns true if the stack is full,
// otherwise returns false.
virtual void push(const Type& newItem) = 0;
//Function to add newItem to the stack.
//Precondition: The stack exists and is not full.
//Postcondition: The stack is changed and newItem
// is added to the top of the stack.
virtual Type top() const = 0;
//Function to return the top element of the stack.
//Precondition: The stack exists and is not empty.
//Postcondition: If the stack is empty, the program
// terminates; otherwise, the top element
// of the stack is returned.
virtual void pop() = 0;
//Function to remove the top element of the stack.
//Precondition: The stack exists and is not empty.
//Postcondition: The stack is changed and the top
// element is removed from the stack.
};
//Definition of the node
template <class Type>
struct nodeType
{
Type info;
nodeType<Type> *link;
};
template <class Type>
class linkedStackType: public stackADT<Type>
{
public:
const linkedStackType<Type>& operator=
(const linkedStackType<Type>&);
//Overload the assignment operator.
bool isEmptyStack() const;
//Function to determine whether the stack is empty.
//Postcondition: Returns true if the stack is empty;
// otherwise returns false.
bool isFullStack() const;
//Function to determine whether the stack is full.
//Postcondition: Returns false.
void initializeStack();
//Function to initialize the stack to an empty state.
//Postcondition: The stack elements are removed;
// stackTop = nullptr;
void push(const Type& newItem);
//Function to add newItem to the stack.
//Precondition: The stack exists and is not full.
//Postcondition: The stack is changed and newItem
// is added to the top of the stack.
Type top() const;
//Function to return the top element of the stack.
//Precondition: The stack exists and is not empty.
//Postcondition: If the stack is empty, the program
// terminates; otherwise, the top
// element of the stack is returned.
void pop();
//Function to remove the top element of the stack.
//Precondition: The stack exists and is not empty.
//Postcondition: The stack is changed and the top
// element is removed from the stack.
linkedStackType();
//Default constructor
//Postcondition: stackTop = nullptr;
linkedStackType(const linkedStackType<Type>& otherStack);
//Copy constructor
~linkedStackType();
//Destructor
//Postcondition: All the elements of the stack are
// removed from the stack.
bool operator==(const linkedStackType<Type>& otherStack) const;
// declaring the function for == operator overloading
private:
nodeType<Type> *stackTop; //pointer to the stack
int count;
void copyStack(const linkedStackType<Type>& otherStack);
//Function to make a copy of otherStack.
//Postcondition: A copy of otherStack is created and
// assigned to this stack.
};
//Default constructor
template <class Type>
linkedStackType<Type>::linkedStackType()
{
stackTop = nullptr;
count=0;
}
template <class Type>
bool linkedStackType<Type>::isEmptyStack() const
{
return(stackTop == nullptr);
} //end isEmptyStack
template <class Type>
bool linkedStackType<Type>:: isFullStack() const
{
return false;
} //end isFullStack
template <class Type>
void linkedStackType<Type>:: initializeStack()
{
nodeType<Type> *temp; //pointer to delete the node
while (stackTop != nullptr) //while there are elements in
//the stack
{
temp = stackTop; //set temp to point to the
//current node
stackTop = stackTop->link; //advance stackTop to the
//next node
delete temp; //deallocate memory occupied by temp
}
} //end initializeStack
template <class Type>
void linkedStackType<Type>::push(const Type& newElement)
{
nodeType<Type> *newNode; //pointer to create the new node
newNode = new nodeType<Type>; //create the node
newNode->info = newElement; //store newElement in the node
newNode->link = stackTop; //insert newNode before stackTop
stackTop = newNode; //set stackTop to point to the
count++;
//top node
} //end push
template <class Type>
Type linkedStackType<Type>::top() const
{
assert(stackTop != nullptr); //if stack is empty,
//terminate the program
return stackTop->info; //return the top element
}//end top
template <class Type>
void linkedStackType<Type>::pop()
{
nodeType<Type> *temp; //pointer to deallocate memory
if (stackTop != nullptr)
{
temp = stackTop; //set temp to point to the top node
stackTop = stackTop->link; //advance stackTop to the
//next node
count--;
delete temp; //delete the top node
}
else
cout << "Cannot remove from an empty stack." << endl;
}//end pop
template <class Type>
void linkedStackType<Type>::copyStack
(const linkedStackType<Type>& otherStack)
{
nodeType<Type> *newNode, *current, *last;
if (stackTop != nullptr) //if stack is nonempty, make it empty
initializeStack();
if (otherStack.stackTop == nullptr)
stackTop = nullptr;
else
{
current = otherStack.stackTop; //set current to point
//to the stack to be copied
//copy the stackTop element of the stack
stackTop = new nodeType<Type>; //create the node
stackTop->info = current->info; //copy the info
stackTop->link = nullptr; //set the link field of the
//node to nullptr
last = stackTop; //set last to point to the node
current = current->link; //set current to point to
//the next node
//copy the remaining stack
while (current != nullptr)
{
newNode = new nodeType<Type>;
newNode->info = current->info;
newNode->link = nullptr;
last->link = newNode;
last = newNode;
current = current->link;
}//end while
}//end else
} //end copyStack
//copy constructor
template <class Type>
linkedStackType<Type>::linkedStackType(
const linkedStackType<Type>& otherStack)
{
stackTop = nullptr;
copyStack(otherStack);
}//end copy constructor
//destructor
template <class Type>
linkedStackType<Type>::~linkedStackType()
{
initializeStack();
}//end destructor
//overloading the assignment operator
template <class Type> const linkedStackType<Type>& linkedStackType<Type>::operator= (const linkedStackType<Type>& otherStack) {
if (this != &otherStack) //avoid self-copy
copyStack(otherStack);
return *this;
}//end operator=
template <class Type> bool linkedStackType<Type>::operator== (const linkedStackType<Type>& otherStack) const {
if (this == &otherStack)
return true; //same object being tested
else {
// test count value
//return false if count value differs
if (count != otherStack.count) {
cout<<"Count is not same";
return false;
}
//falls thru here if two stack has same length
//for loop
//return false if any value differs
nodeType<Type> *tempStack1, *tempStack2;
tempStack1 = stackTop;
tempStack2 = otherStack.stackTop;
for(int i = 0; i < count;i++) {
if (tempStack1->info != tempStack2->info)
return false;
tempStack1 = tempStack1->link;
tempStack2 = tempStack2->link;
}
return true;
}
}
int main() {
linkedStackType < int >stack1;
linkedStackType < int >stack2;
stack1.initializeStack ();
stack2.initializeStack ();
stack1.push (23);
stack1.push (45);
stack1.push (38);
stack1.push (32);
stack2.push (23);
stack2.push (45);
stack2.push (38);
stack2.push (32);
stack1.pop();
if (stack1 == stack2)
cout << " EQUAL";
else
cout << " NOT equal";
cout << endl;
return 0;
}
Thanks.
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.