einfach verkettete Liste

Hallo,

im folgenden geht es um eine einfach verkettete Liste. Ich hab`s mal versucht zu implementieren. Leider klappt das nicht mit dem compilieren. Außerdem hab ich wahrscheinflich tausend Sachen vergessen. Könnt ihr vielleicht mal drüber schauen und mein Programm verbessern.

class Cell
{
    protected:
      Cell* next;
      Cell() 
      {
       this->next = NULL;
      }

    public:
      virtual void print() const = 0;

    friend class Liste;      
};

class Messwert : public Cell
{
      private:
        long wert;

      public:
        Cell(long messwert)
        {
           wert = messwert;
        }

        void print() 
        {
             cout << wert;
        }
};

class Liste
{
  private:
    Cell* firstPtr;
    Cell* lastPtr;

  public:

    Liste()
    {
      firstPtr = NULL;
      lastPtr = NULL;
    }

    void append(Cell* zeiger)
    {
      *lastPtr.next = *zeiger;
      lastPtr = *zeiger;
    } 

    Cell* get()
    {
      if(firstPtr == NULL)
        return NULL;
      else
      {
        Cell* entnommen = *firstPtr;
        firstPtr = *firstPtr.next
        return entnommen;
      }
    }

    void display()
    {
      Cell* merker = *firstPtr;   

      while(merker != NULL)
      {
        *merker.print();      
        merker = *merker.next;
      }
    }
};

shapeless

hmm was hast du denn für compilerfehler ?
wie wäre es mit zB

insert
sort
front
back
find

funktionen. denn bisher hängst du ja nur mittels append an.

Folgender Fehler tritt auf:

In constructor Cell::Cell()':NULL' undeclared (first use this function)
(Each undeclared identifier is reported only once for each function it appears in.)

Nun geht es mir aber nicht nur darum den Compilerfehler zu beheben. Ich will auch wissen ob ich das mit den Zeigern bei den verschiedenen Funktion richtig gemacht habe?

shapeless

void append(Cell* zeiger)
    {
      *lastPtr.next = *zeiger;
      lastPtr = *zeiger;
    }
// ich denke du solltest überlegen ob und was du hie wirklich dereferenzieren solltest 
//Bsp:
//blubb *ptr;
//ptr = der zeiger ( also der ort auf den er zeit)   
//*ptr der wert des zeigers ( also der wert dessen das auf das der Zeiger zeigt)
//&ptr adresse des Zeigers ( hier nicht wichtig)
//wenn du will das ein zeiger auf einen anderen zeigt dann musst du dafür nicht
//dereferenzieren...

        Cell* entnommen = *firstPtr;
//soll das auf das entnommen zeigt ( afaik undefinier hier) den wert von 
//firstptr bekommen oder solls auf die erste position zeigen , wennletzteres , warum dereferenzieren? 

        firstPtr = *firstPtr.next
//pass bitte auf, denn struct->member ist unglich *struct.member
//hier musst du schauen das du klammern setzt wenn du schon keine ->
// schreibweise nehmen willst also (*struct).member...

    void display()
    {
      Cell* merker = *firstPtr;  // sieh oben

      while(merker != NULL)
      {
        *merker.print(); //siehe oben klammern oder ->     
        merker = *merker.next;//das gleiche
      }
    }
};

Hallo,

Wäre das jetzt so in Ordnung oder stecken immernoch Fehler drin? Was das compilieren angeht das klappt immernoch nicht. Es tritt nach wie vor der oben schon angesprochene Fehler auf. Könnt ihr mir sagen was ich am Code ändern muss damit auch das compilieren funktioniert?

class Cell
{
    protected:
      Cell* next;
      Cell() 
      {
       this->next = NULL;
      }

    public:
      virtual void print() const = 0;

    friend class Liste;      
};

class Messwert : public Cell
{
      private:
        long wert;

      public:
        Cell(long messwert)
        {
           wert = messwert;
        }

        void print() 
        {
           cout << wert;
        }
};

class Liste
{
  private:
    Cell* firstPtr;
    Cell* lastPtr;

  public:

    Liste()
    {
      firstPtr = NULL;
      lastPtr = NULL;
    }

    void append(Cell* zeiger)
    {
      lastPtr->next = zeiger;       // oder (*lastPtr).next = zeiger;
      lastPtr = zeiger;
    } 

    Cell* get()
    {
      if(firstPtr == NULL)
        return NULL;
      else
      {
        Cell* entnommen = firstPtr;
        firstPtr = firstPtr->next;  // oder firstPtr = (*firstPtr).next
        return entnommen;
      }
    }

    void display()
    {
      Cell* merker = firstPtr;      // firstPtr (der Ort auf den firstPtr zeigt)  

      while(merker != NULL)
      {
        merker->print();            // oder (*merker).print();
        merker = merker->next;      // merker = (*merker).next;
      }
    }
};

shapeless

hmm 2 Dingen sind mir so auf den ersten Blick aufgefallen:

void append(Cell* zeiger)
    {
      lastPtr->next = zeiger;       // oder (*lastPtr).next = zeiger;
      lastPtr = zeiger;
    }

Du sollstest lastPtr->next= NULL;
setzen, da du ja mit while(...!=NULL)
durch die Liste iterierst...(display funktion)

2)initionalisierungliste:
dein c-tor in Messwert ist verwirrend. Meinst du statt Cell() nicht Messwert()
wenn ja Messwert(long mwert):wert(mwert>){}

Und der Compilierungsfehler

shapeless

afaik ist NULL nen define aus der stddef.h ...
also einfach

#include<cstddef>

es sollte aber durch iostream schon ingebunden sein. Wenn dem nicht so ist
probiers mal so

Hallo,

vielen Dank für die super Hilfe.

Also dann bis zum nächsten Problem...

Werner Salomon

GR_Watto schrieb:

Also dann bis zum nächsten Problem...

.. und das steht schon da. Wenn' kompilieren soll musst Du noch die Metode print in 'Messwert' const machen

//        void print()
        void print() const
        {
            std::cout << wert;
        }

und wenn es dann auch noch laufen soll, so fehlt mindestens die Abfrage von 'lastPtr' auf NULL in Liste::append; für den Fall, dass in Liste noch gar keine Cell's drin sind.

void append(Cell* zeiger)
    {
        if( lastPtr) 
        {
            lastPtr->next = zeiger;       // oder (*lastPtr).next = zeiger;
        }
        else
        {
            firstPtr = zeiger;
        }
        lastPtr = zeiger;
    }

bleibt noch die Frage: Welche der Klassen soll sich um die livetime der Cell-Objekte kümmern? Oder anders gefragt, wann und wie werden die Cell-Objekte und deren Derivate wieder gelöscht?

Gruß
Werner

Hallo,

wie könnte der Code zum Löschen der Objekte denn aussehen?

shapeless

hmm ganz klassisches Löschen eines Elementes einer Liste. du Suchst zuerst das zu löschende Element, dafür durchläufst sie,zB mittels:
Cell * current;
cur=kopf;
while(cur->next!= NULL)
cur=cur->next;
if(cur->next=zu suchendes)
....
wenn du dies nun hast kannst du ja
nen temp auf das auszuhängende zeigen lasen und zB
cur->next =cur->next->next machen und damit das element auf das temp zeigt (aushängen) das musst du noch löschen und du solltest fertig sein...
Ist nur mal so schnell aus dem kopf aber sollte funktionieren....