c++ visual studio 2019

Do not use #include

fix the program circularqueue.cpp created so that it is related to the circularlist.cpp and list2.h I have provided (makes more sense once you read the original question)

original question: Use your circular list implementation to implement a circular queue in the following three ways:

• Using composition
• Overriding selected public methods with private methods
• Using private inheritance.

The circular queue should expose only 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.

circularqueue.cpp----------------------------------------------------------------------

#include  using namespace std; int cqueue[5]; int front = -1, rear = -1, n=5; void insertCQ(int val) { if ((front == 0 && rear == n-1) || (front == rear+1)) { cout<<"Queue Overflow "; return; } if (front == -1) { front = 0; rear = 0; } else { if (rear == n - 1) rear = 0; else rear = rear + 1; } cqueue[rear] = val ; } void deleteCQ() { if (front == -1) { cout<<"Queue Underflow "; return ; } cout<<"Element deleted from queue is : "<>ch; switch(ch) { case 1: cout<<"Input for insertion: "<>val; insertCQ(val); break; case 2: deleteCQ(); break; case 3: displayCQ(); break; case 4: //to check the Queue is empty or not if (front == -1) { cout<<"Queue is empty"< rear ? (n - front + rear + 1) : (rear - front + 1); cout<<"number of elements in the Queue is "< 
 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; };
 
 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; }