c++ visual studio 2019

Do not use #include

help me fix my program so that it does not crash. I added the thing my professor said that needs for it to be fixed

***Problem 1 a) is still not good. I separated the main function and changed it to test the circular list. I am attaching your implementation and my main program. The program crashes when going back from the first element to last element. We also need to test all other methods of the List class. I suggest, after fixing the current crash, you test them before you continue with 1.a.ii and 1.a.iii.

You have also programmed functions empty() and print(), but they need to be member functions. For that you will need to change the list2.h file. ****

original question:

Convert it to a circular list. The node after the last node should be the first node. The node before the first node should be the last node. Do not change the implementation of class Node.

1. Implement all operations currently available in the class List. Do not change file list2.h.
2. Add a method empty(), which should return true if the circular list is empty and false otherwise.
3. Add a method print() to print the values in the nodes of the circular list, from the first to the last node.

main.cpp---------------------------------------------------------

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

using namespace std;

/** * Checks if the passed circular list is empty. * @param list the circular list to check * @return true if the circular list is empty and false otherwise */ bool empty(List& list) { return list.begin().equals(Iterator{}); }

/** * Prints the values in the nodes of the list * from the first to the last. * @param list the circular list to print */ void print(List& list) { for (Iterator it{ list.begin() }; !it.equals(list.end()); it.next()) { cout << it.get() << " "; } }

int main() { List staff;

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

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

for (int i = 0; i < 5; i++){ cout << pos.get() << " "; pos.previous(); system("pause"); } // We also need to test all other methods

return 0; }

list.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; }

}

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 { before->next = after;

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

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; 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 != container->first); if (position == NULL) position = container->last; else position = position->previous; }

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

list.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(); 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; };