Redo the simulation program of Chapter 17 so that it uses the STL class queue to
ID: 667087 • Letter: R
Question
Redo the simulation program of Chapter 17 so that it uses the STL class queue to maintain the list of waiting customers
The chapter 17 simulation program uses 4 classes -customerType, serverType, serverListType, and waitingCustomerQueueType. Students should modify the main function to use queue STL container, instead of waitingCustomerQueueType class. So, there are not many changes in the three classes.
What students should do is:
- run the original program and understand how each member function works
- then determine which member function will be affected by switching to the queue STL container.
- make necessary changes
- runSimulation function of the main program must include the followings to use a queue:
queue<customerType> customerQueue;
customerType customer;
Explanation / Answer
simulation.cpp
queueADT.H
//Header file: stackADT.h
#ifndef H_queueADT
#define H_queueADT
template <class Type>
class queueADT
{
public:
virtual bool isEmptyQueue() const = 0;
virtual bool isFullQueue() const = 0;
virtual void initializeQueue() = 0;
//Function to initialize the queue to an empty state.
//Postcondition: The queue is empty
virtual Type front() const = 0;
//Function to return the first element of the queue.
//Precondition: The queue exists and is not empty.
//Postcondition: If the queue is empty, the program
// terminates; otherwise, the first element of the queue
// is returned.
virtual Type back() const = 0;
//Function to return the last element of the queue.
//Precondition: The queue exists and is not empty.
//Postcondition: If the queue is empty, the program
// terminates; otherwise, the last element of the queue
// is returned.
virtual void addQueue(const Type& queueElement) = 0;
//Function to add queueElement to the queue.
//Precondition: The queue exists and is not full.
//Postcondition: The queue is changed and queueElement is
// added to the queue.
virtual void deleteQueue() = 0;
//Function to remove the first element of the queue.
//Precondition: The queue exists and is not empty.
//Postcondition: The queue is changed and the first element
// is removed from the queue.
};
#endif
queueAsArray.h
//Header file QueueAsArray
#ifndef H_QueueAsArray
#define H_QueueAsArray
#include <iostream>
#include <cassert>
#include "queueADT.h"
using namespace std;
//*************************************************************
// Author: D.S. Malik
//
// This class specifies the basic operation on a queue as an
// array.
//*************************************************************
template <class Type>
class queueType: public queueADT<Type>
{
public:
const queueType<Type>& operator=(const queueType<Type>&);
//Overload the assignment operator.
bool isEmptyQueue() const;
//Function to determine whether the queue is empty.
//Postcondition: Returns true if the queue is empty,
// otherwise returns false.
bool isFullQueue() const;
//Function to determine whether the queue is full.
//Postcondition: Returns true if the queue is full,
// otherwise returns false.
void initializeQueue();
//Function to initialize the queue to an empty state.
//Postcondition: The queue is empty
Type front() const;
//Function to return the first element of the queue.
//Precondition: The queue exists and is not empty.
//Postcondition: If the queue is empty, the program
// terminates; otherwise, the first element of the
// queue is returned.
Type back() const;
//Function to return the last element of the queue.
//Precondition: The queue exists and is not empty.
//Postcondition: If the queue is empty, the program
// terminates; otherwise, the last element of the queue
// is returned.
void addQueue(const Type& queueElement);
//Function to add queueElement to the queue.
//Precondition: The queue exists and is not full.
//Postcondition: The queue is changed and queueElement is
// added to the queue.
void deleteQueue();
//Function to remove the first element of the queue.
//Precondition: The queue exists and is not empty.
//Postcondition: The queue is changed and the first element
// is removed from the queue.
queueType(int queueSize = 100);
//Constructor
queueType(const queueType<Type>& otherQueue);
//Copy constructor
~queueType();
//Destructor
private:
int maxQueueSize; //variable to store the maximum queue size
int count; //variable to store the number of
//elements in the queue
int queueFront; //variable to point to the first
//element of the queue
int queueRear; //variable to point to the last
//element of the queue
Type *list; //pointer to the array that holds
//the queue elements
};
template <class Type>
bool queueType<Type>::isEmptyQueue() const
{
return (count == 0);
} //end isEmptyQueue
template <class Type>
bool queueType<Type>::isFullQueue() const
{
return (count == maxQueueSize);
} //end isFullQueue
template <class Type>
void queueType<Type>::initializeQueue()
{
queueFront = 0;
queueRear = maxQueueSize - 1;
count = 0;
} //end initializeQueue
template <class Type>
Type queueType<Type>::front() const
{
assert(!isEmptyQueue());
return list[queueFront];
} //end front
template <class Type>
Type queueType<Type>::back() const
{
assert(!isEmptyQueue());
return list[queueRear];
} //end back
template <class Type>
void queueType<Type>::addQueue(const Type& newElement)
{
if (!isFullQueue())
{
queueRear = (queueRear + 1) % maxQueueSize; //use mod
//operator to advance queueRear
//because the array is circular
count++;
list[queueRear] = newElement;
}
else
cout << "Cannot add to a full queue." << endl;
} //end addQueue
template <class Type>
void queueType<Type>::deleteQueue()
{
if (!isEmptyQueue())
{
count--;
queueFront = (queueFront + 1) % maxQueueSize; //use the
//mod operator to advance queueFront
//because the array is circular
}
else
cout << "Cannot remove from an empty queue" << endl;
} //end deleteQueue
//Constructor
template <class Type>
queueType<Type>::queueType(int queueSize)
{
if (queueSize <= 0)
{
cout << "Size of the array to hold the queue must "
<< "be positive." << endl;
cout << "Creating an array of size 100." << endl;
maxQueueSize = 100;
}
else
maxQueueSize = queueSize; //set maxQueueSize to
//queueSize
queueFront = 0; //initialize queueFront
queueRear = maxQueueSize - 1; //initialize queueRear
count = 0;
list = new Type[maxQueueSize]; //create the array to
//hold the queue elements
} //end constructor
//Destructor
template <class Type>
queueType<Type>::~queueType()
{
delete [] list;
} //end destructor
template <class Type>
const queueType<Type>& queueType<Type>::operator=
(const queueType<Type>& otherQueue)
{
cout << "Write the definition of the function "
<< "to overload the assignment operator." << endl;
} //end assignment operator
template <class Type>
queueType<Type>::queueType(const queueType<Type>& otherQueue)
{
cout << "Write the definition of the copy constructor."
<< endl;
} //end copy constructor
#endif
test.cpp
#include <iostream>
#include <cstdlib>
#include <iomanip>
#include "simulation.h"
#include "queueAsArray.h"
using namespace std;
void setSimulationParameters(int& sTime, int& numOfServers,
int& transTime,
int& tBetweenCArrival);
void runSimulation();
int main()
{
runSimulation();
return 0;
}
void setSimulationParameters(int& sTime, int& numOfServers,
int& transTime,
int& tBetweenCArrival)
{
cout << "Enter the simulation time: ";
cin >> sTime;
cout << endl;
cout << "Enter the number of servers: ";
cin >> numOfServers;
cout << endl;
cout << "Enter the transaction time: ";
cin >> transTime;
cout << endl;
cout << "Enter the time between customer arrivals: ";
cin >> tBetweenCArrival;
cout << endl;
}
void runSimulation()
{
cout << "Write the definition of the function runSimulation." << endl;
cout << "See programming Exercise 8." << endl;
}
simulation.h
#include <fstream>
#include <string>
#include "queueAsArray.h"
using namespace std;
//************************************************************
// Author: D.S. Malik
//
// class customerType
// This class specifies the members to implement a customer.
//************************************************************
class customerType
{
public:
customerType(int cN = 0, int arrvTime = 0, int wTime = 0,
int tTime = 0);
//Constructor to initialize the instance variables
//according to the parameters
//If no value is specified in the object declaration,
//the default values are assigned.
//Postcondition: customerNumber = cN; arrivalTime = arrvTime;
// waitingTime = wTime; transactionTime = tTime
void setCustomerInfo(int cN = 0, int inTime = 0,
int wTime = 0, int tTime = 0);
//Function to initialize the instance variables.
//Instance variables are set according to the parameters.
//Postcondition: customerNumber = cN; arrivalTime = arrvTime;
// waitingTime = wTime; transactionTime = tTime;
int getWaitingTime() const;
//Function to return the waiting time of a customer.
//Postcondition: The value of waitingTime is returned.
void setWaitingTime(int time);
//Function to set the waiting time of a customer.
//Postcondition: waitingTime = time;
void incrementWaitingTime();
//Function to increment the waiting time by one time unit.
//Postcondition: waitingTime++;
int getArrivalTime() const;
//Function to return the arrival time of a customer.
//Postcondition: The value of arrivalTime is returned.
int getTransactionTime() const;
//Function to return the transaction time of a customer.
//Postcondition: The value of transactionTime is returned.
int getCustomerNumber() const;
//Function to return the customer number.
//Postcondition: The value of customerNumber is returned.
private:
int customerNumber;
int arrivalTime;
int waitingTime;
int transactionTime;
};
//************************************************************
// Author: D.S. Malik
//
// class serverType
// This class specifies the members to implement a server.
//************************************************************
class serverType
{
public:
serverType();
//Default constructor
//Sets the values of the instance variables to their default
//values.
//Postcondition: currentCustomer is initialized by its
// default constructor; status = "free"; and the
// transaction time is initialized to 0.
bool isFree() const;
//Function to determine if the server is free.
//Postcondition: Returns true if the server is free,
// otherwise returns false.
void setBusy();
//Function to set the status of the server to busy.
//Postcondition: status = "busy";
void setFree();
//Function to set the status of the server to "free."
//Postcondition: status = "free";
void setTransactionTime(int t);
//Function to set the transaction time according to the
//parameter t.
//Postcondition: transactionTime = t;
void setTransactionTime();
//Function to set the transaction time according to
//the transaction time of the current customer.
//Postcondition:
// transactionTime = currentCustomer.transactionTime;
int getRemainingTransactionTime() const;
//Function to return the remaining transaction time.
//Postcondition: The value of transactionTime is returned.
void decreaseTransactionTime();
//Function to decrease the transactionTime by 1 unit.
//Postcondition: transactionTime--;
void setCurrentCustomer(customerType cCustomer);
//Function to set the info of the current customer
//according to the parameter cCustomer.
//Postcondition: currentCustomer = cCustomer;
int getCurrentCustomerNumber() const;
//Function to return the customer number of the current
//customer.
//Postcondition: The value of customerNumber of the
// current customer is returned.
int getCurrentCustomerArrivalTime() const;
//Function to return the arrival time of the current
//customer.
//Postcondition: The value of arrivalTime of the current
// customer is returned.
int getCurrentCustomerWaitingTime() const;
//Function to return the current waiting time of the
//current customer.
//Postcondition: The value of transactionTime is returned.
int getCurrentCustomerTransactionTime() const;
//Function to return the transaction time of the
//current customer.
//Postcondition: The value of transactionTime of the
// current customer is returned.
private:
customerType currentCustomer;
string status;
int transactionTime;
};
//************************************************************
// Author: D.S. Malik
//
// class serverListType
// This class specifies the members to implement a list of
// servers.
//************************************************************
class serverListType
{
public:
serverListType(int num = 1);
//Constructor to initialize a list of servers
//Postcondition: numOfServers = num
// A list of servers, specified by num, is created and
// each server is initialized to "free".
~serverListType();
//Destructor
//Postcondition: The list of servers is destroyed.
int getFreeServerID() const;
//Function to search the list of servers.
//Postcondition: If a free server is found, returns its ID;
// otherwise, returns -1.
int getNumberOfBusyServers() const;
//Function to return the number of busy servers.
//Postcondition: The number of busy servers is returned.
void setServerBusy(int serverID, customerType cCustomer,
int tTime);
//Function to set a server busy.
//Postcondition: The server specified by serverID is set to
// "busy", to serve the customer specified by cCustomer,
// and the transaction time is set according to the
// parameter tTime.
void setServerBusy(int serverID, customerType cCustomer);
//Function to set a server busy.
//Postcondition: The server specified by serverID is set to
// "busy", to serve the customer specified by cCustomer.
void updateServers(ostream& outFile);
//Function to update the status of a server.
//Postcondition: The transaction time of each busy server
// is decremented by one unit. If the transaction time of
// a busy server is reduced to zero, the server is set to
// "free". Moreover, if the actual parameter corresponding
// to outFile is cout, a message indicating which customer
// has been served is printed on the screen, together with the
// customer's departing time. Otherwise, the output is sent
// to a file specified by the user.
private:
int numOfServers;
serverType *servers;
};
//************************************************************
// Author: D.S. Malik
//
// class waitingCustomerQueueType
// This class extends the class queueType to implement a list
// of waiting customers.
//************************************************************
class waitingCustomerQueueType: public queueType<customerType>
{
public:
waitingCustomerQueueType(int size = 100);
//Constructor
//Postcondition: The queue is initialized according to the
// parameter size. The value of size is passed to the
// constructor of queueType.
void updateWaitingQueue();
//Function to increment the waiting time of each
//customer in the queue by one time unit.
};
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.