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