Add code to the header and main file to meet standards Files outline are at end
ID: 3579406 • Letter: A
Question
Add code to the header and main file to meet standards Files outline are at end of post make sure it runs as shown
1. Make the following changes to the stack class:
Make all necessary changes to have the class store integers on the stack instead of characters. pop should return -1 if called when the stack is empty.
Add a print member function that prints the values in the stack from top to bottom, one per line.printshould not change the stack.
Write an elements member function that returns the number of elements on the stack. elementsshouldnotprint anything. elements should not change the stack.
Write a peek member function that returns the top element on the stack. peek returns -1 if the stack isempty. peek should not change the stack.
2. Write a simulation of dishwashing at a restaurant in the file stack.cpp. There will be a stack of dishes to be washed. The following variables are used in the program. A number of them have set values. Your program should still work properly if the values are changed.
// total number of minutes in the simulation
int total_minutes = 100,
// print results every print_minutes minutes
print_minutes = 10,
// largest size dish (dish values randomly set
// from 1 to max_dish)
max_dish = 5,
// number of dishes added each minute
add_dishes = 5,
// total size of dishes a washer can wash in one minute
wash_size = 5,
// number of diswashers read from user
dishwashers;
The simulation will run for total_minutes simulated minutes. The current state of the stack will be printed every print_minutes minutes. Dishes on the stack will be represented by integers indicating how big they are (random values from 1 to max_dish). There will be add_dishes random dishes added each minute. Each dishwasher can wash wash_size dishes each minute taken from the top of the stack. So, ifwash_sizeis 5, and the current stack is:
3
1
3
4
the dishwasher could wash the top two plates. The third plate would take the amount of dishes washed over 5. There will be dishwashers (entered by the user) dishwashers working.
A general algorithm for the simulation would thus be:
read number of dishwashers
for (minutes from 1 to total_minutes)
{
add add_dishes random dishes to the stack
for (each dishwasher)
{
wash wash_size dishes from the stack
}
if (it is time to print based on print_minutes)
{
print the current time
print the stack of dishes
print the number of dishes in the stack
}
}
The following page has a sample run. To make the run shorter, total_minutes was set equal to 30). Feel free to change the variable values to help test/debug your program. The simulation should generate different sets of random dishes each run. That is, use srand appropriately :
srand((unsigned)time(NULL)); // Put at beginning of main to seed rand.
L = rand( ) % max_dish + 1; // generates a number between 1 and max_dish
stack.cpp file
stack.h file
sample run:
Enter the number of dishwashers: 3
Time = 10
Dishes in stack:
4
3
Elements in stack: 2
Time = 20
Dishes in stack:
4
4
4
3
1
3
3
Elements in stack: 7
Time = 30
Dishes in stack:
3
3
4
2
4
4
4
3
1
3
3
Elements in stack: 11
Explanation / Answer
#include <iostream>
02
#include <cstdlib> // for random variety functions
03
#include <ctime> // for clock functions
04
using namespace std;
05
06
#include "DynQueue.h" // needs queue ADT
07
08
double randVal(); // model for random generation perform
09
10
const double NORTH_SOUTH_ARRIVE_FREQ = one.0/10.0; // Prob. of automotive inward every second
11
const double EAST_WEST_ARRIVE_FREQ = one.0/30.0; // Prob. of automotive inward every second
12
const int REDLIGHTON = 120;
13
const int GREENLIGHTON = 360;
14
15
const int SIM_TIME = 3600; // In seconds
16
const int> 17
18
int main()
19
discovered for random variety generator
21
srand(time(0)); // Set seed for random variety to clock
22
23
24
// Variables
25
DynQueue<int> northSouth_q; // north/south queue
26
DynQueue<int> eastWest_q; // east/west queue
27
28
int time; // clock for simulation
29
int i;
30
31
32
int northSouthCars = 0; // Total arrival counter
33
int EastWestCars = 0; // Total departures counter
34
35
// SIMULATION
36
for (time=1;time <= SIM_TIME; time++)
37
42
if (randVal() <= EAST_WEST_ARRIVE_FREQ) // New departure
43
46
//commented out as a result of i detected that i need the employment of (is empty) however it'd still
47
//i will see however its not getting to work as a result of if it absolutely was not empty it'd still dequeue nothing, or try to
48
// for (i = 0; i <= GREENLIGHTON; i++)
49
//
53
//
54
// for (i = 0; i <= GREENLIGHTON; i++)
55
//
59
60
61
62
}
63
}
64
65
/*************************************************************************/
66
/* This functions returns as random variety between zero.0 and 1.0 */
67
/*************************************************************************/
68
double randVal()
69
come back double(rand()) / double(RAND_MAX);
71
}
template <class ItemType>
002
class DynQueue
003
;
010
011
NodeType *front;
012
NodeType *rear;
013
int numItems;
014
public:
015
DynQueue();
016
~DynQueue();
017
void enqueue(ItemType);
018
ItemType dequeue();
019
bool isEmpty();
020
bool isFull();
021
void clear();
022
};
023
024
#endif
025
026
//==================================================
027
//Implementation for Dynamic Queue category
028
//==================================================
029
030
#include <iostream>
031
using namespace std;
032
033
//************************
034
// creator *
035
//************************
036
037
template <class ItemType>
038
DynQueue<ItemType>::DynQueue()
039
044
045
//************************
046
// Destructor *
047
//************************
048
049
template <class ItemType>
050
DynQueue<ItemType>::~DynQueue()
051
054
055
//********************************************
056
// perform enqueue inserts the worth in num *
057
// at the rear of the queue. *
058
//********************************************
059
060
template <class ItemType>
061
void DynQueue<ItemType>::enqueue(ItemType item)
062
073
else
074
078
numItems++;
079
}
080
081
//**********************************************
082
// perform dequeue removes the worth at the *
083
// front of the queue, and copies it into num. *
084
// PRECONDITION: Queue isn't empty *
085
//**********************************************
086
087
template <class ItemType>
088
ItemType DynQueue<ItemType>::dequeue()
089
temporary worker = front;
095
front = front->next;
096
delete temp;
097
numItems--;
098
come back returnItem;
099
}
100
101
//*********************************************
102
// perform isEmpty returns true if the queue *
103
// is empty, and false otherwise. *
104
//*********************************************
105
106
template <class ItemType>
107
bool DynQueue<ItemType>::isEmpty()
108
standing = false;
113
else
114
standing = true;
115
come back status;
116
}
117
118
//****************************************************
119
// Member perform isFull is assumed to be false. *
120
// Tailor to native operational atmosphere. *
121
//****************************************************
122
123
template <class ItemType>
124
bool DynQueue<ItemType>::isFull()
125
{
126
come back false;
127
}
128
129
//********************************************
130
// perform clear dequeues all the weather *
131
// within the queue. *
132
//********************************************
133
134
template <class ItemType>
135
void DynQueue<ItemType>::clear()
136
worth = dequeue();
141
}
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.