Question

C++

Create an array-based implementation of a stack. Each element of the stack should store a string.

The stack class should include 3 private member variables (maximum stack size, top of the stack index, and a pointer to the array that holds the stack elements).

Public member methods should include a constructor (with an argument of stack maximum size that is used to create a dynamic array), a destructor (that deletes the dynamic array), a push method (argument is a string), a pop method (returns a string), an empty method (returns bool), and a full method (returns bool).

• Do not use structs for this assignment.
• Do not use templates for this assignment.

In your driver program, create a stack with a maximum stack size of 5 elements. Present a menu to the user when the program begins:

1. Push an item onto stack
2. Pop an item from stack
3. Quit

The push option should call the full method and provide a message if the stack is full. If not, it should ask the user for a data item from the keyboard. It will then call the stack's push method.

The pop option should call the empty method and provide a message if the stack is empty. If not, it should call the pop method which returns the item removed from the stack. The main driver should display the data item that was removed from the stack.

• Upload a zipped file that contains only the following 3 files:
  • Stack.h
  • Stack.cpp
  • StackDriver.cpp

Answer 1

Stack.h:

#pragma once
#include <iostream>
using namespace std;
class Stack
{
private:
   int max_size;
   int top;
   string* array;
public:
   Stack(int );
   ~Stack();
   void push(string );
   string pop();
   bool empty();
   bool full();
};

Stack.cpp:

#include "Stack.h"
// constructor
Stack::Stack(int max_size)
{
   this->max_size = max_size;
   this->array = new string[max_size];
   top = -1;
}
// destructor
Stack::~Stack()
{
   delete[] array;
}
// pushes to stack
void Stack::push(string value)
{
   top++;
   array[top] = value;
}
// returns popped element
string Stack::pop()
{
   top--;
   return array[top + 1];
}
// returns true if stack is empty
bool Stack::empty()
{
   if (top == -1)
       return true;
   return false;
}
// returns true if stack is full
bool Stack::full()
{
   if (top == max_size - 1)
       return true;
   return false;
}

StackDriver.cpp:

// do comment if any problem arises
// code
#include"Stack.h"
int main()
{
   // create a stack of maximum size 5
   Stack testing(5);
   while (true)
   {
       int choice;
       cout << "\n1. Push an item onto stack\n";
       cout << "2. Pop an item from stack\n";
       cout << "3. Quit\n";
       cout << "Your choice: ";
       cin >> choice;
       if (choice == 1)
       {
           if (testing.full())
               cout << "Stack is full!\n";
           else
           {
               cout << "Enter data: ";
               string temp;
               cin >> temp;
               testing.push(temp);
           }
       }
       else if (choice == 2)
       {
           if (testing.empty())
               cout << "Stack is empty!\n";
           else
               cout << "Popped item: " << testing.pop() << endl;
       }
       else
           break;
   }
}

Output: