//note: program has been re-written in visual studio using both features from the new and the original implementation that i've been taught. //sidenote: temp just means "temporary pointer". /**Problems: * * fixed the memory leaks, but, suprise! now all the nodes have the same garbage value, something like "-842150451". * */ //syntax to handle possible memory leaks. //includes from CRT library to check for memory leaks. //#define _CRTDBG_MAP_ALLOC #include //#include /**Changes: * Currently trying to fix up some memory leaks. * Changed all "nullptr" to nullptr. * added a constructor for "Node" struct. * added shared smart pointers and got rid of most of the constructor method. * any changes to list length are done at the beginning of a method. * gotten rid of make_shared(), stopping on of the three errors. * initizilised the "data" node struct member in the constructor. */ #include #include #include //we'll be using unique_ptr as our pointer here. using namespace std; struct node { int data; shared_ptr next; node(int data) { data = data; next = nullptr /**make_shared(nullptr)*/; //by default we've initialised "Next" as nullptr. } }; class linkedList { private: shared_ptr head; shared_ptr tail; int length = 0; public: //constructors and destructors. linkedList() { head = nullptr; tail = nullptr; } ~linkedList()//there's a problem with the destructor. { cout << "De-allocation completed, resources restored to the computer." << endl; } //method to display data of the nodes. void displayNodes() { shared_ptr temp; //fixed previous memory leak here. temp = head; while (temp != nullptr) { cout << temp->data << " " << flush; temp = temp->next; } cout << " " << endl; //i'm using " " to ensure a empty line is printed. } //insertion methods. void insertStart(int value) { shared_ptrnewNode(new node(value)); if (newNode != nullptr) { //newNode->data = value; newNode->next = head; head = newNode; ++length; } cout << "New node created as head node, with value " << newNode->data << endl; } void insertIndex(int pos, int value) { ++length; //we first need an algorithim to reach the required index of the linked list. shared_ptrpre; //dummy pointers here are only for iteration and do not require any allocation of memory. shared_ptrcur; shared_ptrnewNode(new node(value)); cur = head; for (int index = 0; index < pos; index++) { pre = cur; cur = cur->next; } //newNode->data = value; pre->next = newNode; //these two lines here make sure to sandwich the new node in between the previous and the current node; newNode->next = cur; cout << "New node created at position " << pos << ", of value " << newNode->data << endl; } void insertEnd(int value) //add from the function "Createnode" from the initial iteration of the linked list. { ++length; shared_ptrnewNode(new node(value)); //newNode->data = value; newNode->next = nullptr; cout << "New value appended to the end of the list, with value " << newNode->data << endl; if (head == nullptr) { head = newNode; tail = newNode; newNode = nullptr; //i don't understand this line of code. } else { tail->next = newNode; //the previous tail now points at the new node. tail = newNode; //here, the tail now points at the new node appended to the end of the list. } } void deleteStart() { --length; if (length > 0) { shared_ptrtemp = head; head = head->next; temp.reset(); //the only bug left; how does one delete shared pointers? } } void deleteIndex(int pos) { --length; shared_ptr pre; shared_ptrcur; cur = head; for (int index = 0; index < pos; index++) { pre = cur; cur = cur->next; } pre->next = cur->next; //this isolates the node in the desired position from the list. cur = nullptr; pre = nullptr; cur.reset(); pre.reset(); } void deleteEnd()//memory leak detected here.//i'm up to here. { --length; if (length > 0) { shared_ptr cur; shared_ptr pre; cur = head; while (cur != tail) { pre = cur; cur = cur->next; } tail = pre; pre->next = nullptr; cur = nullptr; cur.reset();//i need to check whether this is supposed to be there. //i'm assuming reset is akin to deletion, so that's why i'm adding it. } } void showLength() { cout << "Length of list: " << length << endl; } void gap() { cout << "---------------------------------------------------------" << endl; } }; int main() { linkedList L; L.insertEnd(12); L.insertEnd(243); L.insertEnd(13); L.insertEnd(78); L.gap(); //display test. cout << "Initial list: " << endl; L.displayNodes(); L.showLength(); L.gap(); //insertion tests. L.insertStart(92); cout << "List after insertion at the start:" << endl; L.displayNodes(); L.showLength(); L.gap(); L.insertIndex(1, 17); cout << "List after insetion at index 1:" << endl; L.displayNodes(); L.showLength(); L.gap(); L.insertEnd(18); cout << "List after insertion at the end:" << endl; L.displayNodes();//note: new nodes on the end of the list can't be properly connected to the list, so change in method is nessecary. L.showLength(); L.gap(); //deletion tests. L.deleteStart(); cout << "List after the deletion of the first node:" << endl; L.displayNodes(); L.showLength(); L.gap(); //Something is extremely wrong with the deletion method. cout << "List after deletion of index 2:" << endl; L.deleteIndex(2); L.displayNodes(); L.showLength(); L.gap(); L.deleteEnd(); cout << "List after deletion on the end:" << endl; L.displayNodes(); L.showLength(); L.gap(); //more CRT library syntax //_CrtDumpMemoryLeaks(); //_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_DEBUG); //system("Pause"); return 0; }

Linked lists in c++(using shared pointers)