Problem mit verketteten Listen

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