Problem bei eigener LinkedList

Firefighter

Sorry ich brauche nochmal eure Hilfe bei der Swap Funktion, ich tue mich ein wenig Schwer mit dem Zeigerwirrwarr. Zurzeit sieht es so hier aus:

template<class T>
LinkedList<T>& LinkedList<T>::swap_list(const LinkedList& list)
{
    Item* temp = this->first;
    this->first = list->first;
    list->first = temp;

    return this;

}

Leider führt das nur zu Fehlern

drakon

Was für Fehler?

Das alleine kann ja schon nicht gehen.

return this;

Nutzt doch einfach std::swap:

template<class T>
LinkedList<T>& LinkedList<T>::swap_list(const LinkedList& list)
{
    std::swap (this->first, list.first);
    return *this;
}

Firefighter

hmm --.-- ich dummkopf, danke dir

camper

const ?

Firefighter

Habe ich mich auch gerade gefragt, weil mit const geht es leider nicht :(Und auch ohne Const kriege ich eine Segmentation Fault

camper

Firefighter schrieb:

Habe ich mich auch gerade gefragt, weil mit const geht es leider nicht

Darf ich das unter "Redewendungen, die ihr hasst" zitieren? :

Firefighter schrieb:

Und auch ohne Const kriege ich eine Segmentation Fault

Was heißt auch? Du kriegst den segfault auch mit const?

Firefighter

@camper:

Kannst du gerne zitieren wenn dich das glücklich macht Aber ich werde mich sofort selber schlagen, weil diese Aussage von mir sehr schwammig war

Nein mit const kriege ich keinen Segmentation Fault.Sondern einen Fehler welchen ich gerade nicht posten kann, da ich das Programm auf arbeit habe.

Firefighter

So da bin ich nochmal mit der Fehlermeldung welche auftritt wenn ich const wieder reinpacke:

D:\Coding\Cpp\LinkedList\LinkedList.h||In member function `LinkedList<T>& LinkedList<T>::swap_list(const LinkedList<T>&) [with T = int]':|

Ich hoffe ihr könnte mir weiterhelfen?
Entschuldigt bitte nochmal meine Ungenauigkeit in den vorherigen Posts.

LordJaxom

Firefighter schrieb:

D:\Coding\Cpp\LinkedList\LinkedList.h||In member function `LinkedList<T>& LinkedList<T>::swap_list(const LinkedList<T>&) [with T = int]':|

Ich hoffe ihr könnte mir weiterhelfen?

Wenn Du jetzt zu der Information, in welcher Funktion der Fehler aufgetreten ist, noch die eigentliche Fehlermeldung schreibst, dann ja :p

Ok, eigentlich brauche ich die garnicht, aber Du willst ja sicher auch lernen die Fehlermeldungen richtig einzuordnen. Das Problem ist, dass Du an einem konstanten Objekt nichts ändern kannst (logisch, oder?), also auch nichts tauschen. Da müssen wir an der non-const Version weiterforschen.

Firefighter

Klaro will ich was lernen Und natürlich ist es logisch das man an einem const-Objekt nix ändern kann...Leider kommt bei der nicht-const Variante ebend der besagte Segmentation Fault. Danke Lord, bei dir habe ich immer das Gefühl du bleibst selbst bei den dümmsten Fragen immer Ruhig und versuchst es gut zu erklären, was ja meistens auch funktioniert

EDIT: Und das finde ich Super

Firefighter

Ich habe folgendes festgestellt
hier meine Main.cpp

#include <iostream>
#include<time.h>
#include<string>
#include "LinkedList.h"

using namespace std;

int main()
{
    srand(unsigned(time(NULL)));
    LinkedList<int> list;
    LinkedList<int> list2;

    for(int i = 0;i<10;i++)
    {

        list.pushfront(rand()%490);
        list2.pushfront(rand()%49);
    }
    list.pushfront(100);
    list.sort_list();
    list.swap_list(list2);

    if(list.delete_item(list.find(100)))
    {
        cout<<"Element wurder erfolgreich geloescht."<<endl;
    }
    else
    {
        cout<<"Element nicht vorhanden!"<<endl;
    }
    for(int i = 0;i<list.size();i++)
    {
       cout<<list[i]<<endl;
    }
return 0;

}

so wenn ich nun ganz unten in der Ausgabe anstatt list dafür list2 hinschreibe, dann funktioniert alles. sobald ich aber list wieder nehme, kriege ich den Segmentation Fault. Kann es sein das sich durch das swap die Zeiger auf den anfang wieder ein wenig verhackt haben?? Und ich somit wieder irgendwo lesen will, wo mal wieder nix ist?

LordJaxom

Swappst Du auch die Größe?

Firefighter

Ahhh vergessen, ich denke mal das hier

std::swap(this->m_length,list.m_length);

ist es dann gewesen oder?:D

Firefighter

Ich muss doch nochmal stören, könnt ihr mir vieleicht beim erstellen des Kopierkonstruktors ein wenig helfen?

Zur Zeit sieht mein Konstrukt so aus, leider fährt er sich fest,d.h. er rast in eine Endlosschleife.

template<class T>
LinkedList<T>::LinkedList(const LinkedList &link)
{

    this->m_length = link.m_length;
    while(link.first->next != NULL)
    {        //std::cout<<link.first->data<<std::endl;
        this->first = link.first;
        this->first = this->first->next;
    }

}

Ich muss doch zuerst die Größe der neuen Liste an meine alte zuweisen. Und dann muss ich doch Knotenweiße kopieren oder sehe ich das falsch?

camper

Firefighter schrieb:

Ich muss doch zuerst die Größe der neuen Liste an meine alte zuweisen. Und dann muss ich doch Knotenweiße kopieren oder sehe ich das falsch?

Nein. Allerdings sehe ich weder eine Schleife, die jemals abbrechen könnte (wenn sie es nicht sofort tut), noch den Versuch, irgendetwas zu kopieren.

LordJaxom

Genau hinschauen hilft oft!

Du fragst in der Schleife ab, ob der erste Knoten der rechten Liste einen Nachfolger hat. Du änderst die rechte Liste (bzw. das, was in der Bedingung geprüft wird) aber nirgendwo, folglich kann sich das Ergebnis der Bedingung nie ändern.

Zunächst mal möchtest Du über alle Knoten der rechten Liste gehen. Da die rechte Liste konstant ist (Du möchtest den Inhalt der rechten Liste kopieren, das Original dabei aber in Ruhe lassen), brauchst Du eine eigene Laufvariable dafür, und kannst nicht link.first direkt nehmen. Dann möchtest Du das jeweils aktuelle Element kopieren, solange ein aktuelles Element da ist (wichtig für die Abbruchbedingung!).

Item const* lauf = link.first; // Laufvariable
while (/* _aktueller_ Knoten gültig, sprich != 0? */) {
    /* kopiere Element aus lauf in die this-Liste */

    /* und weiterzählen der Laufvariable (ändern von lauf), damit sich das Ergebnis der Bedingung auch mal ändert, wäre auch nicht verkehrt */
}

Den Rest lasse ich erstmal wieder zur Übung

Firefighter

EDIT: Ich hab Müll geschrieben. Lord hat mal wieder den Tag gerettet... Danke so eine Erklärung hilft wirklich beim Lernen.

LordJaxom

In dem Beispiel hast Du in der Bedingung aber die Knoten der this-Liste. Du möchtest aber doch eine Schleife über die Knoten der link-Liste?!

Zu den beiden Zeilen in der Schleife bringe ich mal folgendes Beispiel:

i = 10; // (1)
i = 12; // (2)
// Welche Wirkung hat Zeile (1)? Richtig, garkeine, i wäre nach Zeile (2) == 12, egal ob Zeile (1) existiert oder nicht

Aber Du hast doch Funktionen zum Einfügen einzelner Elemente, die auch m_length mit hochzählen, oder? Ich denke das meinte Camper mit "nein [du brauchst die Länge nicht zuerst zu kopieren]"?

Firefighter

Ja klar, die Funktionen habe ich und die zählen auch hoch, damit ergibt das "Nein" von camper auch für mich Sinn

Firefighter

Aber Lord sollte ich da nicht einen Fehler bekommen?? wenn ich das hier versuche

template<class T>
LinkedList<T>::LinkedList(const LinkedList &link)
{
    Item const* lauf = link.first;

    while(lauf != NULL)
    {
        this->first = lauf;
        lauf = lauf->next;

    }

}

Dann ist es doch eine Invalid Conversion von this->first(nicht const) und lauf(const)??