c++ Projekt Dubbel Länkad Lista

Trädvy Permalänk
Medlem
Registrerad
Aug 2013

c++ Projekt Dubbel Länkad Lista

Hålloj,
Jag håller på med ett projekt i c++ som går ut på att man ska skapa en doubbel länkad lista, i den lista 1 och lista 2 ska man slumpa fram tal mellan 1-100. I den tredje listan ska man bara skriva över allt från lista 1 till lista 3 och i lista 4 så ska man slå i samman lista 1 och 2 till lista 4 sorterad.

då till mitt problem är att jag får fel kod när jag använder mig av en tilldelnings operator i main, programmet skriver ut lista1,2 och 3 men sen så kraschar det och error meddelandet jag får är 255 <0xFF>.

Tack på förhand!

postar min kod här nere.

#ifndef LLIST_H_INCLUDED #define LLIST_H_INCLUDED #include <iostream> class linked_list { public: linked_list(); linked_list(const linked_list& src); linked_list& operator =(linked_list& rhs); // adds elements to the back . linked_list& operator +=(const linked_list& rhs); //Destruktor ~linked_list(); // inserting elements void insert(double value, size_t pos); // in front void push_front(double value); // in back void push_back(double value); // accessing elements double front() const; double back() const; double at(size_t pos) const; // removing elements void remove(size_t pos); // remove and access double pop_front(); double pop_back(); // informational size_t size() const; bool is_empty() const; // output void print() const; void print_reverse() const; //void linked_list::sort(); private: struct node_t { node_t() { next = NULL; prev = NULL; value = NULL; } node_t(double value, node_t *next = 0, node_t *prev = 0); double value; node_t *next; node_t *prev; }; node_t *head; node_t *tail; }; #endif // LLIST_H_INCLUDED

#include <iostream> #include "llist.h" using namespace std; //Head och tail sätts till NULL linked_list::linked_list() { head = 0; tail = 0; } //en tilldelningsoperator med en linked_list som input. linked_list::linked_list(const linked_list& src) { node_t *flytt; flytt = src.head; while (flytt->next != 0) { this->push_back(flytt->value); flytt = flytt->next; } } // = operatorn ger möjlighet att kopiera en lista till en ny lista. linked_list &linked_list::operator =(linked_list& rhs) { node_t *flytt; flytt = rhs.head; node_t *temp; if (head == NULL) //om listan är tom { while (flytt != 0) //så länge som flytt inte är null trycker push_back funktionen in ett nytt tal. { push_back(flytt->value); flytt = flytt->next; head = rhs.head; } } else { //om listan inte är tom linked_list tempor; while (flytt->next != 0) { tempor.push_back(flytt->value); flytt = flytt->next; } rhs.~linked_list(); // ta bort ? this->~linked_list(); temp = tempor.head; while (temp != 0) { rhs.push_back(temp->value); // ta bort? this->push_back(temp->value); temp = temp->next; } } return *this; } // plus operatorn lägger till värden i slutet av en ny lista linked_list& linked_list::operator +=(const linked_list& rhs) { node_t *flytt; flytt = rhs.head; while (flytt != 0) //så länge som pekaren inte är null, för in det kopierade värdet i slutet på "nya" listan och flytta noden ett steg fram. { push_back(flytt->value); flytt = flytt->next; } return *this; } //Destruktorn förstör en lista för att hindra minnesläckage linked_list::~linked_list() { node_t *temp; temp = head; while (temp->next != NULL) { temp = temp->next; delete[] temp->prev; } delete[] temp; head = NULL; tail = NULL; // // /* // while (tail != head) // { // tail = tail->prev; // delete[] tail->next; // } // delete head; // head = NULL; // tail = NULL; // */ } // införande av en nod med ett värde på en specifik plats void linked_list::insert(double value, size_t position) { node_t *temp = new node_t; node_t *flytt; temp->value = value; if (head != NULL) { flytt = head; if (position < 1) //Denna if sats körs bara om head behöver bytas ut. { flytt = head; head = temp; head->next = flytt; flytt->prev = head; head->prev = NULL; } else { for (size_t i = 1; i < position; i++) //for loopen går igenom länkade listan tills den hamnar på den position användaren vill föra in värdet. { if (flytt->next != NULL) { flytt = flytt->next; } else { break; } } temp->prev = flytt->prev; temp->next = flytt; flytt->prev = temp; temp->prev->next = temp; flytt = temp->next; if (flytt != NULL) { flytt->prev = temp; } } if (tail->next != NULL) tail = tail->next; } else { head = temp; tail = temp; } } //För in ett värde i listans bakre del void linked_list::push_back(double value) { node_t *rikimauru = new node_t; rikimauru->value = value; node_t *flytt; if (head != NULL) { flytt = tail; flytt->next = rikimauru; tail = rikimauru; tail->prev = flytt; tail->next = NULL; } else { head = rikimauru; tail = head; tail->next = NULL; tail->prev = NULL; } } //För in ett värde i listans främre del void linked_list::push_front(double value) { node_t *flytt = new node_t; flytt->value = value; node_t *flytter; if (head != NULL) { flytter = head; flytter->prev = flytt; head = flytt; head->next = flytter; head->prev = NULL; } else { head = flytt; tail = head; head->prev = NULL; tail->next = NULL; } } // Returnar första elementet i listan double linked_list::front() const { if (head != NULL) { return head->value; } else { return NULL; } } //returnar sista elementet i listan double linked_list::back() const { if (tail != NULL) { return tail->value; } else { return NULL; } } //Returnerar elementet på en specifik position genom att stega sig fram till pos genom en for loop. double linked_list::at(size_t pos) const { size_t count; node_t *flytter; flytter = head; if (flytter != NULL) { for (count = 1; count < pos; count++) { if (flytter->next != 0) { flytter = flytter->next; } else { return flytter->value; } } return flytter->value; } else { return 0; } } //Tar bort en nod från en specifik plats genom att stega sig fram med en for loop. void linked_list::remove(size_t pos) { node_t *flyttare; flyttare = head; node_t *hej; if (head != NULL) { for (size_t i = 0; i < pos; i++) { flyttare = flyttare->next; } if (flyttare->prev != NULL) { hej = flyttare->prev; hej->next = flyttare->next; } if (flyttare->next != NULL) { hej = flyttare->next; hej->prev = flyttare->prev; } delete flyttare; } } //Ta bort den sista noden i listan double linked_list::pop_back() { node_t *flytt; double temp=0; if (tail != NULL) { temp = tail->value; flytt = tail; tail = flytt->prev; delete[] flytt; if (tail != NULL) { tail->next = NULL; } } return temp; } //Ta bort den första noden i listan double linked_list::pop_front() { node_t *flytt; double temp=0; if (head != NULL) { temp = head->value; flytt = head; head = flytt->next; delete[] flytt; if (head != NULL) { head->prev = NULL; } } return temp; } // informational // räknar ut size genom att stega sig fram i hela listan i while loopen. Räknaren returnerar sen värdet med listans längd. size_t linked_list::size() const { node_t *pekare; pekare = head; size_t counter = 0; if (head != NULL) { counter = 1; while (pekare->next != NULL) { pekare = pekare->next; counter++; } return counter; } else { return counter; } } bool linked_list::is_empty() const { return head == nullptr; } //print funktion void linked_list::print() const { node_t *flytter; if (head != NULL) { flytter = head; while (flytter != NULL) { cout << flytter->value << ' '; flytter = flytter->next; } cout << "\n" << endl; } else { cout << "tomt" << endl; } } //print fast baklänges! void linked_list::print_reverse() const { node_t *flytter; flytter = tail; if (tail != NULL) { cout << flytter->value << ' '; while (flytter->prev != NULL) { flytter = flytter->prev; cout << flytter->value << ' '; } } else { cout << "tomt" << endl; } }

#include <iostream> #include <ctime> #include <iostream> #include <cstdlib> #include "llist.h" #include <list> #include "llistmain-2015-08-24.cpp" using namespace std; int main() { linked_list listtest; linked_list listtest2; srand((unsigned)time(0)); //Math random ger en ökning genom att ta det tidigare talet, och lägga till en summa för att få en konstant ökning for(int i = 0; i < 100; i++) { listtest.push_back(listtest.back() + rand() %20+1); listtest2.push_back(listtest2.back() + rand() %20+1); } if(listtest.at(50) > listtest2.at(50) ) { cout << "First list holds the biggest value" << endl; listtest.remove(50); } else if(listtest.at(50) == listtest2.at(50)) { cout << "both values in the list are equals" << endl; } else { cout << "Secound list holds the biggest value" << endl; listtest2.remove(50); } cout << endl; cout << "List 1: " << endl; listtest.print(); cout << endl; cout << "List 2: " << endl; listtest2.print_reverse(); listtest2.print(); linked_list listtest3; listtest3 = listtest; for(int i = 0; i < 50; i++) { listtest3.pop_back(); listtest.push_front(listtest3.pop_back()); } cout << endl; cout << endl; cout << "List 3" << endl; listtest3.print(); cout << endl; linked_list listtest4; listtest4 = listtest, listtest2; cout << "List 4 " << endl; //tilldelningsoperator linked_list kraken(listtest); while(!listtest.is_empty()|| !listtest2.is_empty()) { if(listtest2.at(0) == 0) { listtest4 += listtest; break; } else if(listtest.at(0) == 0) { listtest4 +=listtest2; break; } if(listtest.at(0) < listtest2.at(0)) { listtest4.push_back(listtest.at(0)); listtest.pop_front(); } else { listtest4.push_back(listtest2.at(0)); listtest4.pop_front(); } } listtest4.print(); kraken.print(); return 0; }

Trädvy Permalänk
Medlem
Plats
Linköping
Registrerad
Apr 2008
Skrivet av D4HL3N:

// = operatorn ger möjlighet att kopiera en lista till en ny lista.
linked_list &linked_list::operator =(linked_list& rhs)
{
node_t *flytt;
flytt = rhs.head;
node_t *temp;
if (head == NULL) //om listan är tom
{
while (flytt != 0) //så länge som flytt inte är null trycker push_back funktionen in ett nytt tal.
{
push_back(flytt->value);
flytt = flytt->next;
head = rhs.head;
}
}
else
{
//om listan inte är tom
linked_list tempor;
while (flytt->next != 0)
{
tempor.push_back(flytt->value);
flytt = flytt->next;
}
rhs.~linked_list(); // ta bort ?
this->~linked_list();
temp = tempor.head;
while (temp != 0)
{
rhs.push_back(temp->value); // ta bort?
this->push_back(temp->value);
temp = temp->next;
}
}
return *this;
}
[/code]

Det största problemet är att du inte verkar ha tänkt igenom riktigt vad du vill göra, koden är milt sagt underlig t.ex. bör du aldrig kalla på en destruktor manuellt som du gör där, dessutom kör du inte bara destruktor för objektet självt/this utan även rhs destruktor.
Vilka steg behöver du egentligen ha för att kopieringen av noderna från rhs till objektet/this ska gå rätt till (inte läcka minne, inte peka ut samma noder som rhs)?