compiler required: visual studio 2019 and do not use #include bits/stdc++.h

Using the circular list provided below (circularlist.cpp) (important to use the one provided) and make a circular queue that uses

private inheritance composition, and overrides selected public methods with private methods. The queue should only expose the following methods:

-back: Returns the value of the last (most recently added) element at the back of the queue

-empty: Tests if the queue is empty

-front: Returns the value of the element at the front of the queue

-pop: Removes an element from the front of the queue

-push: Adds an element to the back of the queue

-size: Returns the number of elements in the queue

-print: Prints all values in the queue, from the front to the back

circularlist.cpp---------------------------------------------------------------------------

#include #include #include #include "list2.h"

using namespace std;

Node::Node(string s) { data = s; previous = NULL; next = NULL; }

List::List() { first = NULL; last = NULL; }

void List::push_back(string data) { Node* new_node = new Node(data); if (last == NULL) { first = new_node; last = new_node; } else { new_node->previous = last; last->next = new_node; last = new_node; } last->next = first; first->previous = last; }

void List::insert(Iterator iter, string s) { if (iter.position == NULL) { push_back(s); return; } Node* new_node = new Node(s); Node* after = iter.position; Node* before = after->previous;

new_node->previous = before; new_node->next = after; if (before == last) { first = new_node; first->previous = last; last->next = first;

// the previous node of last // should be updated from // pointing to itself to // pointing to the new node last->previous = first; } else { before->next = new_node;

// the previous node of after // should be updated from // pointing to before to // pointing to the new node after->previous = new_node; } }

bool List::empty() { return first == NULL; }

void List::print() { Iterator it = begin();

if (empty()) { cout << "---- Empty List ---- "; return; }

do { cout << it.get() << " "; it.next();

} while (!it.equals(end())); }

Iterator List::erase(Iterator iter) { assert(iter.position != NULL); Node* remove = iter.position; Node* before = remove->previous; Node* after = remove->next;

if (remove == first) { if (first == last) { first = NULL; last = NULL; } else { first = after; first->previous = last; last->next = first; } } else if (remove == last) { // No separate check is necessary // as this has been covered already /** * if (first != last) * { * * **/ last = before; first->previous = last; last->next = first; // } } else { after->previous = before;

// the next node of before // should be updated from // pointing to the remove to // pointing to after before->next = after; }

delete remove;

Iterator r; r.position = after; r.container = this; return r; }

Iterator List::begin() { Iterator iter; iter.position = first; iter.container = this; return iter; }

Iterator List::end() { Iterator iter;

iter.position = last->next; iter.container = this; return iter; }

Iterator::Iterator() { position = NULL; container = NULL; }

string Iterator::get() const { assert(position != NULL); return position->data; }

void Iterator::next() { assert(position != NULL); position = position->next; }

void Iterator::previous() { assert(position != NULL); position = position->previous; }

bool Iterator::equals(Iterator b) const { return position == b.position; }

int main() { List staff;

staff.push_back("Tom"); staff.push_back("Dick"); staff.push_back("Harry"); staff.push_back("Juliet");

cout << " List: "; staff.print(); cout << " empty() returns " << (staff.empty() ? "true" : "false") << endl;

Iterator pos; pos = staff.begin();

cout << " Testing next... "; for (int i = 0; i < 5; i++) { cout << pos.get() << " "; pos.next(); //system("pause"); }

cout << " Testing previous... "; for (int i = 0; i < 5; i++) { cout << pos.get() << " "; pos.previous(); //system("pause"); }

// test all other methods cout << " Inserting \"Ron\" before second element..."; pos = staff.begin(); // Points to first pos.next(); // points to second staff.insert(pos, "Ron");

cout << " List: "; staff.print(); cout << " empty() returns " << (staff.empty() ? "true" : "false") << endl;

cout << " Erasing all items..."; pos = staff.begin();

while (!staff.empty()) { pos = staff.erase(pos); cout << " Removed"; }

cout << " List: "; staff.print(); cout << " empty() returns " << (staff.empty() ? "true" : "false") << endl;

cout << " Testing Ends! " << endl;

return 0; }

list2.h-------------------------------------------------------------------------------------------

#include #include #include

using namespace std;

class List; class Iterator;

class Node { public: /** * Constructs a node with a given data value. * @param s the data to store in this node */ Node(string s);

private: string data; Node* previous; Node* next; friend class List; friend class Iterator; };

class List { public: /** * Constructs an empty list; */ List();

/** * Appends an element to the list. * @param data the value to append */ void push_back(string data);

/** * Inserts an element into the list. * @param iter the position before which to insert * @param s the value to append */ void insert(Iterator iter, string s);

/** * Removes an element from the list. * @param iter the position to remove * @return an iterator pointing to the element after the * erased element */ Iterator erase(Iterator iter);

/** * Gets the beginning position of the list. * @return an iterator pointing to the beginning of the list */ Iterator begin();

/** * Gets the past-the-end position of the list. * @return an iterator pointing past the end of the list */ Iterator end();

/** * Checks if the passed circular list is empty. * @return true if the circular list is empty and false otherwise */ bool empty();

/** * Prints the values in the nodes of the list * from the first to the last. */ void print();

private: Node* first; Node* last; friend class Iterator; };

class Iterator { public: /** * Constructs an iterator that does not point into any list. */ Iterator();

/** * Looks up the value at a position. * @return the value of the node to which the iterator points */ string get() const;

/** * Advances the iterator to the next node. */ void next();

/** * Moves the iterator to the previous node. */ void previous();

/** * Compares two iterators * @param b the iterator to compare with this iterator * @return true if this iterator and b are equal */ bool equals(Iterator b) const;

private: Node* position; List* container; friend class List; };