Description:
Implement a FIFO, First-In-First-Out, data structure,
also known as a "queue." A queue satisfies these
rules:
1) It stores data for us; if we have a queue object, say q, then when we want q to store a
number, say 7.3, we "add" it to the queue with a call: q.Add(7.3). 7.3 is then placed into the queue q and then joins the other numbers that were on the queue.
2) Whenever we go to retreive data called "removing") from the queue, the number we get will always be the "oldest" item that we added. So if we call q.Add() 10 times after the first Add() above,
and then we "remove" a number from the queue, the number returned by the Remove() method will the be 7.3. This also has the effect of removing 7.3 from the queue, so it is no longer there.
If you Add() three times
q.Init();
q.Add(4);
q.Add(9);
q.Add(2);
Then the queue looks like this:
oldest -> 4
9
2
next add ->
If you then Remove() once, the 4 is returned
from the queue and it will then contain:
oldest -> 9
2
next add ->
If you
q.Add(7.3);
at this point the queue becomes:
oldest -> 9
2
7.3
next add ->
If you Remove() now, the 9 will be returned and if you Remove() immediately after that,
the 2 will be returned, leaving only the 7.3 on the queue. I think you get the idea.
Implement a queue of characters using C++. The queue will consist of chars. The size of the queue, implemented using a fixed size array, should be small (say 3 or 5) to easily demonstrate an overflow condition in a test run.
Deliverables:
Thus, after executing the main program segment:
Queue q;
cout << q.Remove() << endl; // should be empty
q.Add('a');
q.Add('b');
q.Add('c');
q.Add('d'); // should overflow
q.Add('e'); // should overflow
cout << q.Remove() << endl;
cout << q.Remove() << endl;
cout << q.Remove() << endl;
cout << q.Remove() << endl; // should be empty
q.Add('h');
q.Add('i');
q.Add('j');
cout << q.Remove() << endl;
cout << q.Remove() << endl;
cout << q.Remove() << endl;
cout << q.Remove() << endl; // should be empty
the output on the screen would look like:
** empty queue **
** full queue **
** full queue **
a
b
c
** empty queue **
h
i
j
** empty queue **
The queue should be designed so that it will not be exhausted
unless the number of items CURRENTLY waiting in the queue equals the size of the queue. That is, a queue defined to have 100 items, should be able to last FOREVER as long as there are
no more than 99 items in the queue at any one time.
Be sure to include a constructor in addition to the Init()
method. An Init() method should do what a constructor does
but in the mid-life of the queue object.
Complete and fully-functional working program(s) in executable form as well as complete source code of all work done. Complete copyrights to all work purchased.
Remember that contacting the other party outside of the site (by email, phone, etc.) on all business projects < $500 (before the buyer's money is escrowed) is a violation of both the software buyer and seller agreements.
We monitor all site activity for such violations and can instantly expel transgressers on the spot, so we thank you in advance for your cooperation.
If you notice a violation please help out the site and report it. Thanks for your help.
|
