verkettete Liste --> Speicherzugriffsfehler

[qwert_zuiopü]

Hallo,

ich bin neu in C und möchte eine verkettete Liste schreiben. Folgender Code:

#include <stdio.h>

struct Listenelement {
	int load;
	struct Listenelement* next;
};

//Anfang der Liste
struct Listenelement* anfang = NULL;

void initializeList() {
	anfang->load = 1;
//	anfang->next = anfang;
}

int main() {
	initializeList();
	return 0;
}

liefert beim ausführen den Fehler "Speicherzugriffsfehler (Speicherabzug geschrieben)". Das sagt mir leider über die Ursache nicht recht viel ;).

Was habe ich falsch gemacht?

[icarus2]

#include <stdio.h> 

struct Listenelement { 
    int load; 
    struct Listenelement* next; 
}; 

//Anfang der Liste 
struct Listenelement* anfang = NULL; 

void initializeList() { 
    anfang->load = 1; // Hier ist anfang == NULL.
//    anfang->next = anfang; 
} 

int main() { 
    initializeList(); 
    return 0; 
}

Das Problem liegt in Zeile 12. Du musst zuerst die Variable 'anfang' initialisieren mit einer Instanz von 'Listenelement'.

[qwert_zuiopü]

Danke, das war ja ein Zeiger :).

Jetzt hab ich allerdings wieder den selben Fehler:

int main() {
	initializeList();
	//*** printf("EINFÜGEN"); *** //HIER tritt der Fehler auf
	elementEinfuegen(4);
	//elementEinfuegen(3);
	//printList();
	return 0;
}

wenn ich die markierte Zeile auskommentiere, funktioniert das Programm nicht. Mit dieser Zeile allerdings schon.
Das verstehe ich nun wirklich nicht.

[DarkShadow44]

Wie genau hast du das andre Problem denn gelöst ?

[qwert_zuiopü]

Das gesamte Programm sieht bisher so aus:

#include <stdio.h>

struct Listenelement {
	int load;
	struct Listenelement* next;
};

//Anfang der Liste
struct Listenelement liste;
struct Listenelement* anfang = &liste;

void elementEinfuegen(int load) {
	printf("%d einfügen",load);
	//Leere Liste
	if(anfang->next == anfang) {
	  printf("anfang->next = anfang");
	  struct Listenelement* next;
	  next->load = load;
	  anfang->next = next;
	  anfang->next->next = anfang;
	} //keine leere Liste
	else {
	  printf("anfang->next != anfang");
	  struct Listenelement* rpointer; //zeigt auf pointer
	  struct Listenelement* pointer;
	  pointer = anfang;
	  while(pointer->next != anfang) {
	    rpointer->next = pointer;
	    pointer = pointer->next;
	  }
	  pointer->load = load;
	  anfang->next=pointer;
	  rpointer->next=anfang;
	}
}

void printList() {
	struct Listenelement* pointer;
	pointer->next = anfang;
	anfang->load = -1;
	while(pointer->next != anfang) {
	  printf("Listenelement: %d",pointer->load);
	}
}

void initializeList() {
	anfang = &liste;
	anfang->load = 1;
	anfang->next = anfang;
}

int main() {
	initializeList();
	printf("EINFÜGEN");
	elementEinfuegen(4);
	//elementEinfuegen(3);
	//printList();
	return 0;
}

Insbesondere die Funktion elementEinfuegen(int) ist noch fehlerhaft, führt aber zumindest zu keinem Programmabbruch, wenn die "printf(...")-Zeile mit dabei ist.

[SeppJ]

Super, jetzt hast du das Problem um eine Stelle verschoben . Vorher hattest du eine leere Liste in die du nichts eingefügt hast. Jetzt hast du eine Liste mit einem Element, die du als leer ansiehst, in die du wieder nichts einfügst.

In deinem Programm sollte wohl mindestens einmal malloc vorkommen, man darf vielleicht sogar so verwegen sein, ein dazu passendes free zu erwarten. Irgendwo müssen schließlich konkrete Listenelemente erzeugt werden. Momentan schiebst du nur Pointer hin und her, die auf nichts zeigen.

Und mach den Unfug mit dem Dummyelement wieder weg. icarus2 wollte mit seinem Tipp bestimmt nicht erreichen, dass du deine Liste auf diese Art und Weise kaputt reparierst.

[qwert_zuiopü]

Ok, danke!
Ich werd mir nochmal Lektüre zu dem Thema vornehmen.

[Wutz]

qwert_zuiopü schrieb:

int main() {
	initializeList();
	//*** printf("EINFÜGEN"); *** //HIER tritt der Fehler auf
	elementEinfuegen(4);
	//elementEinfuegen(3);
	//printList();
	return 0;
}

Warum benutzt du keine C/C++ Code-Tags?
Die Programmstruktur ist anfängerhaft schlecht. Soll erstmal keine Kritik an dir sein, vielleicht hat dir dein Lehrer oder Lehrbuch das so beigebracht.
Durch das Design musst du zwingend mit globalen Variablen arbeiten, C ist aber für Arbeit mit Funktionen prädestiniert, was den Code übersichtlicher und gerade für dich damit das Lernen/Debuggen einfacher macht.
Funktionen können Parameter verarbeiten und somit Funktionalitäten kapseln.
Ein 1. Schritt für besseres Design wäre also z.B.

struct Listenelement {
    int load;
    struct Listenelement* next;
};

int main() {
    struct Listenelement* anfang = NULL; /* keine globale Var. mehr sondern lokal und wird immer an Funktionen mit übergeben! */
	initializeList(&anfang);
	elementEinfuegen(&anfang,4);
	elementEinfuegen(&anfang,3);
	printList(anfang);
	return 0;
}