einfach verkettete liste liefert seg fault

Nobuo T

if (tempptr == NULL)
  {
    tempptr -> dataptr = (struct list*)malloc(sizeof(struct list));
//...

^^^ Das ist auch keine so kluge Idee... Denk mal ganz kurz drueber nach.

Ich weiß nicht wirklich was du meinst... So vielleicht? Ich krieg den Seg fault aber partout nicht raus.

void addElement (void *dataptr, int casttype)
{
  struct list *tempptr;
  tempptr = start;
  // wenn Liste leer, erstes Element einfügen
  if (start == NULL)
  {
    start -> dataptr = malloc(sizeof(struct list));
    start -> next = NULL;
  }
  //ansonsten nächstes Element einfügen
  else
  {
	while (tempptr -> next != NULL)
	{
	  tempptr = tempptr -> next;
	}
	tempptr -> dataptr = malloc(sizeof(struct list));
	tempptr -> next = NULL;
  }
}

supertux

du reservierst Speicher für ein weiteres Listenglied aber den weist du dataptr und nicht next zu. Deine addElement Funktion scheint nicht vollständig zu sein, also bleibt es beim Raten. Poste doch den gesamten Code (und übrigens, malloc casten in in C eine Todsünde)

ok. hier der komplette code:
Das struct rect1 wird vorher noch initialisiert. Aber das funktioniert einwandfrei.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <ctype.h>

typedef struct
{
  char *id;
  int x;
  int y;
  int width;
  int height;
  unsigned char *fill;
} TypeRect;

typedef struct list
{
  void *dataptr;
  int casttype;
  struct list *next;
} TypeList;

struct list *start = NULL;

void addElement (void *dataptr, int casttype)
{
  struct list *tempptr;
  tempptr = start;
  // wenn Liste leer, erstes Element einfügen
  if (start == NULL)
  {
    start -> dataptr = malloc(sizeof(struct list));
    start -> next = NULL;
  }
  //ansonsten nächstes Element einfügen
  else
  {
	while (tempptr -> next != NULL)
	{
	  tempptr = tempptr -> next;
	}
	tempptr -> dataptr = malloc(sizeof(struct list));
	tempptr -> next = NULL;
  }
}

int main ()
{
  TypeRect rect1;
  void *rectptr = &rect1;
  addElement(&rectptr, 1);
  return 0;
}

Nobuo T

Bin ich hier eigentlich der Einzige, dem auffaellt, dass er dort versucht mit einem NULL-Pointer zu adressieren?

Anscheinend.
Wo versuche ich mit nem NULL-Pointer zu addressieren? Der start Pointer muss doch erst auf NULL gesetzt werden. Sonst lässt sich doch nicht überprüfen ob schon was in der Liste ist?
Wie is es richtig? Ich bin ein blutiger Anfänger auf dem Gebiet...

sothis_

struct list *start = NULL; // <- start == null

void addElement (void *dataptr, int casttype)
{
  struct list *tempptr;
  tempptr = start;
  // wenn Liste leer, erstes Element einfügen
  if (start == NULL)
  {
    start -> dataptr = malloc(sizeof(struct list)); //<--- start ist immer noch 0!, "start->" muss in die hose gehen :-)
    start -> next = NULL;
  }

ok. ja versteh ich. Hab das mal geändert. Seg fault is weg. Aber is das so dann richtig?

void addElement (void *dataptr, int casttype)
{
  struct list *tempptr;
  tempptr = start;
  // wenn Liste leer, erstes Element einfügen
  if (start == NULL)
  {
    start = dataptr = malloc(sizeof(struct list));
    start -> next = NULL;
  }
  //ansonsten nächstes Element einfügen
  else
  {
    while (tempptr -> next != NULL)
    {
      tempptr = tempptr -> next;
    }
    tempptr -> dataptr = malloc(sizeof(struct list));
    tempptr -> next = NULL;
  }
}

Nobuo T

Nein, bzw. es ist wenig sinnvoll.

start = dataptr = malloc(sizeof(struct list));

was genau soll diese Zeile bewirken?

tempptr -> dataptr = malloc(sizeof(struct list));
    tempptr -> next = NULL;

Auch hier:
Zuerst mal ist an dieser Stelle tempptr->next bereits NULL. Das war schliesslich genau die Abbruchbedingung der while-Schleife unmittelbar davor und das ist bei einer einfach verketteten Liste auch ein gaengiges Erkennungszeichen des letzten Elements. Die 2. Zeile bewirkt praktisch also genau nichts.

In der 1. Zeile biegst du den Zeiger dataptr der struct list (das letzten Listenelement) auf einen Speicherbereich der Groesse des Structs. Was das bringen soll, kann ich nicht nachvollziehen. Ein weiteres Element wird dort jedenfalls nirgens an next des letzten Elements angefuegt.

Ok, was du da schreibst is einleuchtend.

machen wollte ich eigentlich folgendes:

in der if-Bedingung soll das erste Listenelement eingefügt werden.

wenn der start-pointer != Null ist, bedeutet das ja, dass schon mindestens ein Listenelemnt existiert. In der while-Schleife wird dann der letzte next-Pointer gesucht. Ist dieser gefunden, soll dort das nächste Listenelement angehängt werden.

Allerdings bringe ich das nicht in sinnvollen Code. Hab jetzt dann vmtl. schon jede mögliche Zeichenkombination (außer der richtigen) versucht. (Die meisten liefern nen seg fault)...
Wie gehts richtig?

Kann das so funktionieren?

void addElement (void *dataptr, int casttype)
{
  struct list *tempptr;
  tempptr = start;
  // wenn Liste leer, erstes Element einfügen
  if (tempptr == NULL)
  {
    tempptr = malloc(sizeof(struct list));
    start = tempptr;
  }
  //ansonsten nächstes Element einfügen
  else
  {
	while (tempptr -> next != NULL)
	{
	  tempptr = tempptr -> next;
	}
	tempptr -> next = malloc(sizeof(struct list));
	tempptr = tempptr -> next;
  }
  tempptr -> dataptr = &dataptr;
  tempptr -> casttype = casttype;
  tempptr -> next = NULL; //das soll explizit so gemacht werden, laut Coding standard
}

Nobuo T

Sieht schon sehr gut aus.
Nur eine Sache sehe ich so weit noch:
Dem dataptr willst du sicher nicht die Adresse des als Funktionsparameter uebergebenen void* dataptr zuweisen, sondern dessen Inhalt (da ist ein "&" in Zeile 21 zu viel). Entsprechend natuerlich auch aufpassen, was du der Funktion in diesem Parameter uebergibst (siehe zB. Zeile 56 deines 2. Beitrags - auch hier uebergibst du die Adresse des Pointers, nicht das worauf er zeigt).

Ok. Ja, da hab ich wohl n bisschen zuviel mit Address-of-Operatoren rumgeworfen. Ich weiß, ich stell mich noch n bisschen blöd an...
Danke dir!