C++

As you may recall, the implementation of the cs20::Queue< Object > data structure presented in class used a linked node structure with an identified front and back node. Based on this data structure, write the following method: template bool Queue::separatedBy( Object a, Object b, int amount ) const; This method should determine whether the Queue has the two specified object arguments separated by the desired amount of QueueNodes. Feel free to define any public or private methods or members on the class Queueas you need. Please work with the code from class. For example, please consider the queue shown below:

separatedBy( 8, 20, 1 ) should return false because 8 and 20 are not found on the queue. separatedBy( 12, 20, 1 ) should return false because 20 is not found on the queue. separatedBy( 12, 1, 1 ) should return false because 12 and 1 are not separated by 1 QueueNode on the queue. separatedBy( 12, 1, 3 ) should return true because 12 and 1 are separated by 3 QueueNodes (namely, 5, 7, and 13) on the queue.

code is provided here

https://dropfile.to/QevBJfK access key; 2vs7ny6

https://dropfile.to/W7VaG8c access key: FaQ5K9G

////////////////////////////// CODE//////////////////////////////

//////////////////QueueMenu.cpp//////////////////////////////////////////////

#include

#include "Queue.h"

#include "EmptyQueue.h"

#include "QueueNode.h"

#include "Queue.cpp"

#include "QueueNode.cpp"

using namespace std;

using namespace cs20;

enum CHOICE {MAKEEMPTY, ENQUEUE, ISEMPTY, DEQUEUE, GETFRONT, QUIT, PRINT };

CHOICE menu();

int main(int argc, char* argv[]) {

int value;

Queue q;

CHOICE choice;

do {

choice = menu();

switch( choice ) {

case MAKEEMPTY:

q.makeEmpty();

break;

case ISEMPTY:

if (q.isEmpty()) {

cout << "queue is empty" << endl;

}

else {

cout << "queue is not empty" << endl;

}

break;

case DEQUEUE:

try {

value = q.dequeue();

cout << "Here's the value dequeued: ";

cout << value << endl;

} catch( EmptyQueue eq ) {

cout << "You silly... don't try dequeueing an empty queue!" << endl;

}

break;

case GETFRONT:

try {

value = q.getFront();

cout << "Here's the value returned from getFront: ";

cout << value << endl;

} catch( EmptyQueue eq ) {

cout << "You silly... don't try gettingFront an empty queue!" << endl;

}

break;

case ENQUEUE:

cout << "Please provide int to enqueue: ";

cin >> value;

q.enqueue( value );

break;

case PRINT:

q.printQueue( cout );

cout << endl;

break;

case QUIT:

break;

}

} while (choice != QUIT);

return( 0 );

}

CHOICE menu() {

char choice;

CHOICE result;

cout << "(M)akeEmpty I(s)Empty (E)nqueue (D)equeue (G)etFront (P)rint (Q)uit: " << endl;

cin >> choice;

switch( choice ) {

case 'E':

case 'e':

result = ENQUEUE;

break;

case 'M':

case 'm':

result = MAKEEMPTY;

break;

case 'S':

case 's':

result = ISEMPTY;

break;

case 'D':

case 'd':

result = DEQUEUE;

break;

case 'G':

case 'g':

result = GETFRONT;

break;

case 'Q':

case 'q':

result = QUIT;

break;

case 'P':

case 'p':

result = PRINT;

break;

}

return( result );

}

void sample() {

Queue q1;

Queue q2;

cout << "making q1" << endl;

q1.enqueue( 1 );

q1.enqueue( 2 );

cout << "print q1" << endl;

q1.printQueue( cout );

cout << endl;

cout << "q2 = q1" << endl;

q2 = q1;

cout << "print q2" << endl;

q2.printQueue( cout );

cout << endl;

q1.dequeue();

cout << "dequeue q1" << endl;

cout << "print q2" << endl;

q2.printQueue( cout );

cout << endl;

cout << "print q1" << endl;

q1.printQueue( cout );

cout << endl;

}

//////////////////Queue.h////////////////////////////////////////////////////////////////////////////////////////

#ifndef QUEUE_H

#define QUEUE_H

#include

#include "QueueNode.h"

#include "EmptyQueue.h"

namespace cs20 {

template

class Queue {

public:

Queue();

Queue( const Queue& rhs );

~Queue();

bool isEmpty() const;

void makeEmpty();

void enqueue( const Object& data );

const Object dequeue();

const Object& getFront() const;

const Queue& operator =( const Queue& rhs );

std::ostream& printQueue( std::ostream& outs );

private:

QueueNode