Stack queue

[stunnacplusplus]

I want it to display
something like this

Stack:

Now pushing 3

Now pushing 5

now poping 5

now pushing 2

now poping 2

now poping 3

stack is empty // tried to pop again

Queue:

now pushing 3

now pushing 5

now poping 3

now pushing 2

now poping 5

now poping 2

queue is empty //tried to pop again

  #include<iostream>

using namespace std;
	
class IntStack
{
private:
int *stackArray;
int capacity;
int top;
public:
IntStack(int capacity); // Constructor
~IntStack() { delete[] stackArray; }
void push(int value);
void pop(int &value);
bool isEmpty();
// Stack Exceptions
class Overflow {};
class Underflow {};
};

IntStack::IntStack(int capacity)
{
this->capacity = capacity;
stackArray = new int[capacity];
top = 0;
}
//***********************************
// Adds a value to the stack *
//***********************************
void IntStack::push(int value)
{
if (top == capacity) throw IntStack::Overflow();
stackArray[top] = value;
top++;
}
//****************************************
// Determines whether the stack is empty *
//****************************************
bool IntStack::isEmpty()
{
if (top == 0)
return true;
else
return false;
}
void IntStack::pop(int &value)
{
if (isEmpty()) throw IntStack::Underflow();
top --;
value = stackArray[top];
}

class IntQueue
{
private:
int *queueArray;
int queueSize;
int front;
int rear;
int numItems;
public:
IntQueue(int);
~IntQueue();
void enqueue(int);
void dequeue(int &);
bool isEmpty();
bool isFull();
void clear();
};
//*************************
// Constructor. *
//*************************
IntQueue::IntQueue(int s)
{
queueArray = new int[s];
queueSize = s;
front = -1;
rear = -1;
numItems = 0;
}
//*************************
// Destructor. *
//*************************
IntQueue::~IntQueue()
{
delete [] queueArray;
}
//********************************************
// Function enqueue inserts the value in num *
// at the rear of the queue. *
//********************************************
void IntQueue::enqueue(int num)
{
if (isFull())
{
cout << "The queue is full.\n";
exit(1);
}
else
{
// Calculate the new rear position.
rear = (rear + 1) % queueSize;
// Insert new item.
queueArray[rear] = num;
// Update item count.
numItems++;
}
}
//**********************************************
// Function dequeue removes the value at the *
// front of the queue, and copies it into num. *
//**********************************************
void IntQueue::dequeue(int &num)
{
if (isEmpty())
{
cout << "The queue is empty.\n";
exit(1);
}
else
{
// Move front.
front = (front + 1) % queueSize;
// Retrieve the front item.
num = queueArray[front];
// Update item count.
numItems--;
}
}
//*********************************************
// Function isEmpty returns true if the queue *
// is empty, and false otherwise. *
//*********************************************
bool IntQueue::isEmpty()
{
if (numItems > 0)
return false;
else
return true;
}
//********************************************
// Function isFull returns true if the queue *
// is full, and false otherwise. *
//********************************************
bool IntQueue::isFull()
{
if (numItems < queueSize)
return false;
else
return true;
}
//*******************************************
// Function clear resets the front and rear *
// indices, and sets numItems to 0. *
//*******************************************
void IntQueue::clear()
{
front = - 1;
rear = - 1;
numItems = 0;
}

int main()
{
IntQueue iQueue(5);
IntStack stack(5);
int values[5];
int value;
cout << "Pushing...\n";
for (int k = 0; k < 5; k++)
{
	cin>>values[k];

}

for (int k = 0; k < 5; k++)
{

cout << values[k] << " ";
stack.push(values[k]);
cout << "\nPopping...\n";
iQueue.enqueue(k*k);
cout << "queuing 5 items...\n";
}
while (!stack.isEmpty())
{
stack.pop(value);
cout << value << " ";

iQueue.dequeue(value);
cout << value << " ";
}
cout << endl;

	



return 0;
}