Doppelt verkettete Liste in C++

Heyhey,
ich hätte mal ne kurze Frage, und zwar bei unten aufgeführtem Code funktioniert eigentlich so ziemlich alles, außer dass er anscheinend das erste Element das als Listenstart kreiert wurde irgendwie nicht richtig verlinkt. Man kann zwar nach oben und unten laufen, wenn man Elemente angehängt hat, wenn man aber wieder zurück will, so ist das Element über dem Startelemet irgendwie mit sich selbst verlinkt und das unter dem Startelement auch. So dass man über das Startelement nicht drüberkommt, wenn man last, bzw. next aufruft. Sieht jemand, woran das liegt? Ich bin irgendwie zu blöd dafür, hab schon ne Weile geguckt und versteh es einfach nicht, warum es nur mit dem Startelement Probleme macht und dann reibungsfrei läuft...

Hier ist der Code:

Code:

#include <cstdlib>
#include <iostream>

using namespace std;

template<class T>
class list
{
      public:
           T elem;
           list<T> *next;
           list<T> *last;

           list(T content): elem(content) {
                  next = NULL;
                  last = NULL;
           }
           
           void insert(T toInsert, int pos){
                list<T> *index = this;
                if(pos <= 1)
                     (*this).prepend(toInsert);
                else {                
                     while((*index).last != NULL)
                          index = (*index).last;
                     for(int i = 1; i<pos; i++)
                          index = (*index).next;
                          
                     if(index == NULL)
                          (*this).append(toInsert);
                     else {                          
                          list<T> *create = new list<T>(toInsert);
                          
                          (*create).next = index;
                          (*create).last = (*index).last;
                          (*index).last = create;
                
                          index = (*create).last;
                          if(index != NULL)
                                   (*index).next = create;
                     }
                }
           }
           
           void append(T toAppend){
                list<T> *index = this;
                list<T> *create = new list<T>(toAppend);
                
                while((*index).next != NULL)
                     index = (*index).next;
                     
                (*index).next = create;
                (*create).last = index;
           }
           
           void prepend(T toPrepend){
                list<T> *index = this;
                list<T> *create = new list<T>(toPrepend);
                
                while((*index).last != NULL)
                     index = (*index).last;
                     
                (*create).next = index;
                (*index).last = create;
           }
           
           int countElements(void){
               int count = 1;
               list<T> *index = this;
               
               while((*index).last != NULL){
                     index = (*index).last;
                     count++;
               }
               
               index = this;
               
               while((*index).next != NULL){
                     index = (*index).next;
                     count++;
               }
               return count;
           }   
           
           bool isBegin(void){
                if((*this).last == NULL)
                     return true;
                else
                     return false;
           }     
           
           bool isEnd(void){
                if((*this).next == NULL)
                     return true;
                else
                     return false;
           }      
           
           void printList(void){
                list<T> *index = this;
                while((*index).last != NULL)
                     index = (*index).last;
                     
                while(index != NULL){
                     cout << (*index).elem << " " ;
                     index = (*index).next;
                }
           }
                
                          
};

template<class T>
static list<T> operator++(list<T> &Element){
     if(Element.next != NULL)
          Element = *(Element.next);
     return Element;
}

template<class T>
static list<T> operator++(list<T> &Element,int){
     list<T> temp = Element;
     if(Element.next != NULL)
          Element = *(Element.next);
     return temp;
}

template<class T>
static list<T> operator--(list<T> &Element){
     if(Element.last != NULL)
          Element = *(Element.last);
     return Element;
}

template<class T>
static list<T> operator--(list<T> &Element,int){
     list<T> temp = Element;
     if(Element.last != NULL)
          Element = *(Element.last);
     return temp;
}              

int main(int argc, char *argv[])
{
    list<int> test(1);
    for(int i = -10; i<5; i++)
         test.append(i);
    for(int i = 1; i< 54; i+=6)
         test.prepend(2*i);
         
    int anzahl = test.countElements();
    test.printList();
    cout << endl << "Die Anzahl der Elemente betraegt: " << anzahl << endl;
    cout << (++test).elem << " ";
    cout << (++test).elem << " ";
    cout << (++test).elem << " ";
    cout << (++test).elem << " ";
    cout << (++test).elem << " ";
    cout << (--test).elem << " ";
    cout << (--test).elem << " ";
    cout << (--test).elem << " ";
    cout << (--test).elem << " ";
    cout << (--test).elem << " ";
    cout << (--test).elem << " ";
    cout << (++test).elem << " ";
    cout << (++test).elem << " ";
    cout << (++test).elem << " ";
    cout << (++test).elem << " ";
    cout << (++test).elem << " ";
    cout << (--test).elem << endl;
    
    system("PAUSE");
    return EXIT_SUCCESS;
}

 

Hi,

kannst Du mal bitte die Ausgabe Deines Programms posten? Ich steige momentan nicht ganz dahinter, was da falsch sein soll.

 

Die Ausgabe schaut bei mir folgendermaßen aus:

98 86 74 62 50 38 26 14 2 1 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4
Die Anzahl der Elemente betraegt: 25
-10 -9 -8 -7 -6 -7 -8 -9 -10 -10 -10 -9 -8 -7 -6 -5 -6

Und das macht halt nicht wirklich Sinn, weil nicht dreimal hintereinanter die -10 kommen dürfte. Ist als würd er nicht über das Initiator-Element (die 1) hüpfen können. Und ich check nicht warum, und warum alle anderen klappen...

 

Bist Du Dir sicher, dass die Variante mit den statischen Operatoren auch funktionieren soll, in dieser Variante? Laut des Debuggers liegt nämlich genau in der Zeile

Code:

Element = *(Element.next);

der Hase im Pfeffer. Selbst wenn man den Zuweisungsoperator noch verbiegt, erreicht man offenbar nicht das von Dir gewünschte, nämlich nicht den Inhalt der referenz, sondern die Reeferenz selbst zu verändern.Ich konnte auch nirgends ein Beispiels dafür finden, dass das so gemacht wird bzw gemacht werden kann.
Vielleicht doch lieber mit Iteratorklasse?

 

Ich versteh nicht ganz, was du mit statischen Operatoren meinst, ich hab doch nix als static deklariert, also sollten die Dinger doch auch instanzbezogen sein, oder?
Ich mein, was genau sollte da denn nicht funktionieren, jedes Element hat zwei Objektgebundene Zeiger, die irgendwo in den Speicher hinverweisen.
Und das Ganze funktioniert ja auch, bis auf das Startelement. Ist ja nicht so, dass es grundsätzlich nicht funktionieren würde...
Mein Compiler gibt auch keine Warnung oder sowas dabei aus...
Ich mein, ich könnt es schon anders machen, aber um mein C++ zu verbessern würd ich gerne wissen was da ganz genau schiefläuft...