3. Problem bei eigener LinkedList

Problem bei eigener LinkedList

  • L

    Firefighter schrieb:

    Wenn ich das doch so mache, dann laufe ich ja jedesmal bis zum Ende durch und gebe das Letzte Element zurück? Stehe ich gerade aufem Schlauch?!

    Vielleicht: Ein Konstruktor gibt nichts zurück. Wir reden doch vom Copy-Konstruktor, oder?

    EDIT:
    Nochmal langsam: Du möchtest in einem Copy-Konstruktor an die einzelnen Elemente. Dein Vorschlag war, über den op[] an diese Elemente heranzugehen. Der Einwand war, dass das zu langsam sein könnte, weil dann für jedes Element von Anfang bis zum Element durchgezählt wird. Der Alternativvorschlag war, statt op[] eine Schleife zu verwenden, die wie die in op[] aufgebaut ist. Du solltest nicht op[] verändern.

    0
  • F

    Auch 😃 Von dem und von der Methode operator[] wie die besser gestaltet werden könnte 🙂

    EDIT:Asso...ok dann muss ich das nochmal überarbeiten 🙂

    0
  • L

    Achsooooo (siehe auch mein EDIT im Post oben).

    Da kannst Du beruhigt sein: Bei einer verketteten Liste ohne zusätzlichen Verwaltungsschnickschnack kann der Indexoperator nicht besser implementiert werden. Deshalb bietet die Standardbibliothek auch keinen op[] für std::list an. Wenn Du sowas mit std::list nachbilden willst, muss auch durchgezählt werden.

    0
  • F

    Alles klar, danke dir 🙂 Dann schmeiße ich mein operator[] raus, wenn er nicht mal in der std::list vorgesehen ist, brauche ich den erst recht nicht 🙂

    0
  • F

    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 😞

    0
  • D

    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;
}
    0
  • F

    hmm --.-- ich dummkopf, danke dir 🙂

    0
  • C
    Mod

    const ?

    0
  • F

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

    0
  • C
    Mod

    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?

    0
  • F

    @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.

    0
  • F

    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.

    0
  • L

    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.

    0
  • F

    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 👍

    0
  • F

    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?

    0
  • L

    Swappst Du auch die Größe?

    0
  • F

    Ahhh vergessen, ich denke mal das hier

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

    ist es dann gewesen oder?:D

    0
  • F

    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?

    0
  • C
    Mod

    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.

    0
  • L

    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 😉

    0
Anmelden zum Antworten