Problem mit verketteten Listen

Hallo zusammen,

ich habe folgendes Problem. Ich möchte eine einfach verkette Liste in c++ erstellen.

Dazu habe ich folgende Klasse angelegt:

class Liste
{
   private:
	 struct endteilnehmer {
         short XKoordinate;  
         short YKoordinate;  
         short ID;           
         char status;        
         endteilnehmer *next;           
         struct endteilnehmer *previos; 
      };
      endteilnehmer *head;
   public:

      void PutToList(int x, int y, int art);
};

Nun rufe ich die Funktion PutToList() so auf:

Liste Endteilnehmer; 
Endteilnehmer.PutToList(point.x, point.y, art);

Nun möchte ich in der PutToList() die Übergebenen Werte für x und y in die structur endteilnehmer eintragen und für jedes neu übergebene paar x,y ein neues listenelement hinten anfügen.
Irgendwie steige ich da noch nicht so durch. wäre toll,w enn mir jemand mal auf die sprüge helfen könnte wies weiter geht.
Zuerst wollte ich mal prüfen, ob es überhaupt schon elemente in der List gibt, aber irgendwie hörts da auf.

Wäre toll, wenn mir jemand helfen könnte.

Gruß
Berty

CStoll

Verpass am besten der Elementklasse einen Konstruktor, dann kannst du mit dem folgenden das Element eintragen:

PutToList(short x,short y,int art)
{
  endteilnehmer* data=new endteilnehmer(x,y,art);
  data->next=head->next;
  head->next->previos=data;
  head=data;
}

(btw, die Struktur sieht eher nach doppelt verketteter Liste aus - und in C++ ist die Angabe "struct endteilnehmer ..." überflüssig)

mhh, ich steige da noch nicht ganz durch. ein Konstruktor und Dekonstruktor ist doch so was wie unten eingebaut...aber irgendwie habe ich das mit den Konstruktoren noch nicht geschnallt. Was sollen die denn nun machen?

class Liste
{
   private:
     struct endteilnehmer {
         short XKoordinate;  
         short YKoordinate;  
         short ID;          
         char status;        
         endteilnehmer *next;          
         struct endteilnehmer *previos;
      };
      endteilnehmer *head;
   public:
      void PutToList(int x, int y, int art);
      Liste();
      ~Liste();
};

GPC

Was Konstruktoren machen? Ein Objekt aufbauen.
Was Destruktoren machen? Ein Objekt abbauen.

Was du machen solltest? Ein Tutorial lesen.

GPC

"previous" schreibt man im Übrigen so!

gehts auch so: (ohne Konstruktoren)

PutToList(short x,short y,int art)
{
  endteilnehmer* data=new endteilnehmer;
  data->XKoordinate= x;
  data->YKoordinate= y;
  data->next=head->next;
  head->next->previos=data;
  head=data;
}

GPC

Geht. Aber nicht sehr schön.

ich habe nun mal versucht mir was zusammen zu basteln, aber irgendwie funktioniert das noch nicht so ganz. wäre toll, wenn mal jemand drüber schauen könnte.

class Liste
{
   private:
	  struct endteilnehmer {
              short XKoordinate;    
              short YKoordinate; 
              short ID;                             
              char status;        

              endteilnehmer *next;      
          };
          endteilnehmer *head;
   public:
      int count;
      void PutToList(int x, int y, int art);
     int IsEmpty() const{return !count;}  // Liefert eine 1 zurück, wenn die Liste leer ist
}

void Liste::PutToList(int x, int y, int art)
{   
	int ListeLeer= 0;
	ListeLeer= IsEmpty();

        endteilnehmer *aktuell;
	endteilnehmer *pointer; 
	endteilnehmer *anfang;  

	if(ListeLeer == 1)      
	{
	    if(art == 1)    					 
	    {	
	        endteilnehmer* neuelem=new endteilnehmer;           
                anfang= neuelem;           
                pointer= anfang;            
                pointer->XKoordinate= x;   
                pointer->YKoordinate= y;   
	        pointer->next= NULL;       
             }
        }   
	if(ListeLeer == 0)      
	{
	    if(art == 1)        
	    {	
                endteilnehmer* neuelem=new endteilnehmer; 
                neuelem->XKoordinate= x;                
                neuelem->YKoordinate= y;                
                neuelem->next=NULL;       
	        aktuell->next= neuelem;
	        aktuell= neuelem;
	        aktuell->next=NULL;            
                head=neuelem;
             }
        }

}

Das Programm bleibt immer hänger. ich komme da nciht weiter. liegt vermutlich an den einfüge operationen von neuen listenelementen in die liste.

wäre toll, wennmir da nochmal jemand auf die sprünge helfen könnte.
Grüße
berty

ZuK

Liste hat keinen Konstruktor also ist count nicht initialisiert.
Wahrscheinlich gibt IsEmpty() 0 zurück beim ersten Einfügen.
Kurt

das mit den Konstruktoren habe ich noch nicht ganz verstanden.

Muss ich da z.B das so ändern:

class Liste
{
   private:
      struct endteilnehmer {
              short XKoordinate;    
              short YKoordinate;
              short ID;                            
              char status;        

              endteilnehmer *next;      
          };
          endteilnehmer *head;
   public:
      int count;
      Liste();
      ~Liste();
      void PutToList(int x, int y, int art);
     int IsEmpty() const{return !count;}  // Liefert eine 1 zurück, wenn die Liste leer ist
}

Damit habe ich ja einen Konstruktor und einen Dekonstruktor. Wie kann ich nun count initialisieren?

ZuK

Berty schrieb:

Damit habe ich ja einen Konstruktor und einen Dekonstruktor. Wie kann ich nun count initialisieren?

zb

Liste::Liste():head(0), count(0) {
}

Kurt

ich gebs auf, trotzdem vielen dank