ANSWER

To finish the assignment, you must construct a stack implementation that uses vectors as the container and make numerous changes to the provided code. You should also include exception handling and show how to use STL queue methods. The updated code that satisfies these conditions is shown below:

the cpp
Copy the following code: #include <vector> #include <iostream> #include <queue> #include <stdexcept> As an exception

using the std namespace;

// Custom exceptions class using the StackException class public exception StackException: { string message;

public: }} message(msg) \} StackException(const string& msg)

const throw() const char* what() { return message.c_str(); } };

// Use vector as the container template for stackType (<class Type>).
stack type class { private: vector<Type> list; int stack top; int maxSize;

The stack type is public (int size = 100). {}    if (size <= 0)     size = 100; // Default size     maxSize = size;     stackTop = -1;     list.resize(maxSize);

In the void initializeStack(), stackTop is set to -1;

return stackTop == maxSize – 1;} bool isFullStack() const {

return stackTop == -1; bool isEmptyStack() const {

push(void, const Type& newItem) If (isFullStack()) is true, then { throw StackException(“Stack overflow: Attempt to push onto a full stack.”);
sequence[stackTop] = newItem; stackTop++;

// Using an overload to push several values onto the stack void push(const vector<Type>& items) { for (const Type& item : items) { push(item);

The void pop() function { if (isEmptyStack()) stackTop–; } throw StackException(“Stack underflow: Attempt to pop from an empty stack.”);

Type top() const { -if (isEmptyStack()) { -throw StackException(“Stack underflow: Attempt to access the top of an empty stack.”);
list[stackTop] be returned;

Const stackType<Type>& otherStack === bool operator Const {} ; stackTop!= otherStack.stackTop; if (stackTop!= otherStack.stackTop) ; return false;

for (i <= stackTop; i = 0; i++) It is as follows: { if (list[i]!= otherStack.list[i]) return false; }

come back true; } };

stackType<int> stack1(50); stackType<int> stack2(50); int main() {

stack1.push(23); stack1.push(45); stack1.push(38); stack1.initializeStack();

pile2 = pile 1;

In the event where stack1 == stack2, the code would output “stack1 and stack2 are identical” \\ endl; if not, it would output “stack1 and stack2 are not identical” \\ endl;

stack2.push(32); stack2.pop();

after pop and push operations on stack2 ****, cout \\ “****” \\ endl;

In the event where stack1 == stack2, the code would output “stack1 and stack2 are identical” \\ endl; if not, it would output “stack1 and stack2 are not identical” \\ endl;

pull2.stack(11);

after another push operation on stack2 ****, cout \\ “****” \\ endl;

In the event where stack1 == stack2, the code would output “stack1 and stack2 are identical” \\ endl; if not, it would output “stack1 and stack2 are not identical” \\ endl;

// Using stack type classes to illustrate how to utilize an STL queue queue queue<stackType<int>> stackQueue;

Push Queue stackQueue(stack1); Push Queue(stack2);

“**** Using STL queue methods ****” \\ cout \\ endl;

stackType<int> while (!stackQueue.empty()) {} the currentStack is equal to stackQueue.front(); stackQueue.pop();

if (!currentStack.isEmptyStack()) { cout \\ currentStack.top() \\ endl; cout \\ “Front of the queue: “;
alternatively The output is cout \\ “Empty stack” \\ endl;

0 is returned;
Inside this code

The stack items are now stored in a vector<Type> thanks to modifications made to the stackType class.
Stack underflow (popping from an empty stack), stack overflow (pushing onto a full stack), and accessing the top of an empty stack now have exception handling.
You can now push several values into the stack by using the overloaded push function, which now accepts a vector of items.
The code shows how to store stackType objects in an STL queue and retrieve and remove elements from the queue using the front() and pop() functions.

QUESTION

Description