C-Basics (Linked List)

hi there.

ich muss für die uni wieder c programmieren und diese hardwarenähe macht mir echt zu schaffen inzwischen. jedenfalls ist die aufgabenstellung, eine implementierung einer einfach verketteten liste zu schreiben. ich scheitere irgendwie schon an der append-funktion.

Code:

void Append(IntList *l, int n)
{ 
  IntList neu = (IntList)malloc(sizeof(elemtype));
  neu->wert=n;
  neu->next=NULL;
  if (*l==NULL) //liste leer
  {
    printf("NEU\n");
    *l=neu;
  }
  else
  {
    while ((*l)->next!=NULL)
    {
      printf("Eins weiter\n");
      *l=((*l)->next);
    }
    (*l)->next=neu;
  }
}

ich hab immer nur die letzten 2 elemente in der liste und beim einfügen hangelt er sich auch maximal 1x durch. deswegen nehm ich an, dass in zeile 18 beim anhängen der hund begraben liegt. aber ich seh den fehler einfach nicht, vielleicht steh ich auch komplett auf der leitung.

hat wer einen hint? sorry, falls es wirklich zu offensichtlich ist, aber mmn sollte es so gehen.

tia

der ganze while block ist wahnsinn, ich check ehrlichgsagt im moment ned mal wieso das überhaupt geht... du setzt da den zeiger, welcher auf den listenanfang zeigen soll, ständig weiter...

probier im else zweig mal folgendes:

Code:

IntList *tmp = l;
while((*tmp)->next != null) {
  *tmp = (*tmp)->next;
}
(*tmp)->next = neu;

somit bleibt dein l pointer schön am anfang der kette und du itterierst dennoch durch.

Weiters, nur als Kosmetik: Es ist unschön wenn Liste und Knoten den selben Datentyp haben, weil es das ganze unlustig zum lesen macht. Schöner ist ma haut ein typedef drüber, welcher IntList und IntNode seperat definiert (obwohl sie beide ein und die selbe klasse sind im hintergrund).

edit: ich hätt auch gern den source, irgendwie schaut das ganze gscheit merkwürdig aus (auch was das allokieren und null setzen betrifft...)

Warum eigentlich

Code:

(*temp)->next

und nicht

Code:

temp.next

?

Zitat von jives

Warum eigentlich

Code:

(*temp)->next

und nicht

Code:

temp.next

?

Weil er einen Zeiger auf eine Liste hat und die wiederum auf einen Knoten zeigt

l->next würde nur einmal dereferenzieren, dann dürfte er aber die Liste nicht als Referenz übergeben.

Daher (*l)->next.

Dynamische Objekte werden als Zeiger gehandelt, zwecks dynamischer Bindung. Und da er die Liste ja per maloc erstellt ist sie dynamisch .

Zitat von aNtraXx

Und da er die Liste ja per maloc erstellt ist sie dynamisch .

Ah! Ja, das ist des Rätsels Lösung

Es schaut ungefähr so aus, ja, aber du vermischt doch 2 Dinge miteinander. Du versuchst immer (*tmp)->new zu verwenden, was aber keinen Sinn macht. Also, mit malloc erhältst du die Adresse (Pointer) zu dem neu erstellen Element. Wenn du den Pointer dereferenzierst erhältst du das Element selbst (*tmp). Wenn du dann auf ein Element daraus zugreifen willst kannst du das mit der Punkt Syntax machen (*tmp).new oder aber die Kurzschreibweise mit dem Pfeil tmp->new. Bei dem Pfeil ist eben kein dereferenzieren mehr dabei.
Übrigens ist mir da schon ein Fehler in der ersten Zeile bei deinem Append aufgefallen. Dein neu ist kein Pointer was es aber sein sollte, weil sonst ja der gesamte Sinn von malloc verloren geht.

Zitat von Bowser

Es schaut ungefähr so aus, ja, aber du vermischt doch 2 Dinge miteinander. Du versuchst immer (*tmp)->new zu verwenden, was aber keinen Sinn macht. Also, mit malloc erhältst du die Adresse (Pointer) zu dem neu erstellen Element. Wenn du den Pointer dereferenzierst erhältst du das Element selbst (*tmp). Wenn du dann auf ein Element daraus zugreifen willst kannst du das mit der Punkt Syntax machen (*tmp).new oder aber die Kurzschreibweise mit dem Pfeil tmp->new. Bei dem Pfeil ist eben kein dereferenzieren mehr dabei.
Übrigens ist mir da schon ein Fehler in der ersten Zeile bei deinem Append aufgefallen. Dein neu ist kein Pointer was es aber sein sollte, weil sonst ja der gesamte Sinn von malloc verloren geht.

ich hab noch viel nachzuholen, seh ich grad. danke jedenfalls

da mein rehcner endlich mal wieder rennt hab ich es noch gschwind ausprogrammiert.

der "fallstrick" hier ist, dass IntList selbst schon ein zeiger ist. du hast somit beim append einen zeiger auf einen zeiger.

Code:

void Append(IntList *l, int n)
{ 
	if(*l == 0) {
		*l = (IntList)malloc(sizeof(elemtype));
		(*l)->next = 0;
		(*l)->wert = n;
	} else {	
		IntList tmp = *l;
		while(tmp->next != 0)
			tmp = tmp->next;
			
		IntList neu = (IntList)malloc(sizeof(elemtype));
		neu->next = 0;
		neu->wert = n;
		tmp->next = neu;
	}

}