Elemente in einfache verkettete Liste speichern

[Johannes M. (Gast)]

Hallo!

Ich hab ein Problem, hinter welches ich einfach nicht komm, obwohl's 
wahrscheinlich sehr einfach zu lösen ist.

Und zwar lese ich aus einer Binärdatei Datensätze aus (haben alle 
bestimmte Form aus Header und beliebig langen Content).

Nun schaffe ich es nicht, dass ich, nachdem ich einen Datensatz in das 
1. Listenelement gespeichert habe, auf das nächste Listenelement zu 
springen.

Wenn ich am Ende der While-Schleife, die zum Einlesen eines Datensatzes 
dient, folgendes schreibe:

 first_element_of_list = first_element_of_list->next;

dann bekomme ich jedes Mal einen Segmentation Fault -_-

Wie macht man das, dass man nach dem fertigen Hineinspeichern in das 1. 
Element auf das nächste springt?

[Zerf (Gast)]

Such mal mit dem Debugger die Stelle, an der der Segfault auftritt. Dann 
geht Dir sicher ein Licht auf.

[Johannes M. (Gast)]

So sieht mein Struct aus, das sollte so passen.

Im Programm mach ich jetzt 3 mal fread, einmal für den immer gleich 
großen Header, und zweimal für die beiden variabel langen strings.

typedef struct _Header_
{
  unsigned int identifier;
  double latitude;
  double longitude;
  unsigned int content_length;
}
Header;

typedef struct _Content_
{
  char *place_name;
  char *description;
}
Content;

typedef struct _List_
{
  struct _List_ *next;
  Header header;
  Content content;
}
List;

so im Programm unterhalb definiere ich dann in der Einlesefunktion die 
Liste.

List *first_element_of_single_linked_list;

while(...)
{
.... malloc, fread bla bla bla

?!? first_element_of_single_linked_list = first_element_of_single_linked_list->next;
}

dann mach ich halt die mallocs für den Header, und die beiden Strings 
und lies nach jedem malloc ein.

Zerf schrieb:
> Such mal mit dem Debugger die Stelle, an der der Segfault auftritt. Dann
> geht Dir sicher ein Licht auf.

Wies weiter geht, das weiß ich nicht bzw. schaffe ich es nicht, das 
herauszufinden, das kann doch kein Problem sein für euch, bitte helft 
mir!

[Noname (Gast)]

>.... malloc, fread bla bla bla

ist doch ein bisschen lakonisch und bei der Aufzählung

>dann mach ich halt die mallocs für den Header, und die beiden Strings

vermisse ich das malloc für das Listenelement selbst.
Ich sehe hier bloss Zeiger.

Zeig mal den kompletten Code. Reduziere ihn auf das Notwendigste, so das 
der Fehler noch auftritt.

>Wies weiter geht, das weiß ich nicht bzw. schaffe ich es nicht, das
>herauszufinden, das kann doch kein Problem sein für euch, bitte helft
>mir!
Ist langfristig sowieso keine Lösung. Du kannst ja nicht jedesmal wenn 
ein Problem auftritt sagen: "Ich kann keinen Debugger bedienen, da frag 
ich in mikrocontroller.net".

[Zerf (Gast)]

...nimm den Debugger, kämpf Dich bis zum Segfault und schau Dir die 
Pointer (also deren "Wert") an. Was willst du mit 
"first_element_of_single_linked_list = 
first_element_of_single_linked_list->next;" erreichen?

[Johannes M. (Gast)]

Zerf schrieb:
> Was willst du mit
> "first_element_of_single_linked_list =
> first_element_of_single_linked_list->next;" erreichen?

Ich will damit nach dem Einlesen eines Binärfile-Datensatzes auf das 
nächste Element der Liste springen.
Ich weiß eben nicht, ob ich, wenn ich im nächsten Schleifendurchlauf bin 
und dort wieder ein malloc(sizeof(List)) mache, ob ich ohne die 
Codezeile von oben dann im nächsten Feld der Liste bin oder den 
vorherigen Eintrag überspeichere oder ins 1. Element der Liste noch 
einen zweiten Datensatz hineinspeichere.

[Zerf (Gast)]

Erklär mal genauer. Woher kommt das neue Element?

[Vlad T. (vlad_tepesch)]

warum tut man sich sowas freiwillig auf dem PC an?
nimm doch c++ und eine std::list

[Noname (Gast)]

Ich möchte Dir ernsthaft empfehlen hier den vollständigen Code zu 
zeigen. Deine Erklärungen sind unklar, wozu nicht unwesentlich die 
Identifizierung Deiner Person mit dem Programm und mit Variablen 
beiträgt.

Reduziere ihn auf das zum traversieren der Liste und hinzufügen von 
Elementen notwendige ohne das Einlesen der Strings. Das hinzufügen muss 
auch ohne das funktionieren.

[Johannes M. (Gast)]

List *readInput(char *name_of_file, int *error_code,
  int *number_of_entries)
{
  FILE *input_file;
  char *whole_content_string = NULL;
  List *list;
  int end;
  int counted_content_length = 0;
  int array_index_place_name = 0;
   array_index_description = 0;
  int end_of_word = 0;
  int entry_counter = 0;
  
  *error_code = allocateListMemory(&first_element_of_single_linked_list);
  *error_code = openFile(&input_file, name_of_file, "rb");
 
  do
  {
   fread(&(first_element_of_single_linked_list->header), sizeof(Header),
      1, input_file))    
    
   whole_content_string = malloc(sizeof(char) * 
      first_element_of_single_linked_list->header.content_length);
    
   fread(whole_content_string, list->header.content_length, 1, input_file);

    while(whole_content_string[counted_content_length] != '\0')
    {
      counted_content_length++;
    }
    
    end_of_Word = counted_content_length;
    counted_content_length++;
    
   list->content.place_name =  malloc(sizeof(char) * (end_of_Word + 1));
    
    for(array_index_place_name = 0; array_index_place_name < end_of_Word; array_index_place_name++)
    {
    list->content.place_name[array_index_place_name] = whole_content_string[array_index_place_name];
    }
    list->content.place_name[array_index_place_name] = '\0';
    
    while(whole_content_string[counted_content_length] != '\0')
    {
      counted_content_length++;
    }
    
    list->content.description = malloc(sizeof(char) * (counted_content_length - end_of_Word + 1));;
  
    array_index_place_name = end_of_word;

    for(array_index_description = 0; array_index_description <= (counted_content_length - (array_index_place_name + 1)); array_index_description++)
    {
      list->content.description[array_index_description] = whole_content_string[(end_of_Word + 1)];
      end_of_Word++;
    }
    free(whole_content_string); 
    counted_content_length = 0;

    entry_counter++;
  }
  while(ftell(input_file) != end);
}

[Zerf (Gast)]

Wo findet man in dem Code die Zeile aus Deinem ersten Beitrag?

[Johannes M. (Gast)]

Die sollte ganz unten vor dem Ende der do/while, nur wie schon jetz sehr 
oft von mir gesagt, ich weiß nicht, ob man die braucht. Diese Funktion 
liest Element für Element ein, aber speichert sie diese auch 
nacheinander in die Liste? Das will ich beantwortet haben!

[Johannes M. (Gast)]

aja, ich hab das mit first_element_of_single_linked_list ins list 
umändern wolln, das steht aber leider noch 2-3 mal im code, soll beides 
das gleiche sein!

[Noname (Gast)]

Das kann ja sein, aber ein L-Value der Form list->next erscheint 
nirgends.

Ich bitte Dich ein letztesmal, vollständigen, auf das notwendigste 
(Listenverkettung) Code zu posten und setzt hinzu das er kompilierbar 
sein muss.

So hat das keinen Zweck.

[Noname (Gast)]

Ooops.

Es muss natürlich heissen:

Ich bitte Dich ein letztesmal, vollständigen, auf das notwendigste
(Listenverkettung) reduzierten Code zu posten und setze hinzu das er 
kompilierbar
sein mu

[Johannes M. (Gast)]

So ich hab jetzt eine halbe Stunde lang gegoogelt und bin darauf 
gekommen, dass ich in meinem Programm ganz oben ja die Funktion

*error_code = allocateListMemory(&list);

aufrufe, welche den Befehl

list = malloc(sizeof(List));

beinhaltet.

Mit diese malloc(sizeof(List)) füge ich ja schon ein neues Element ein 
und diese Zeile mit
list = list->next;
ist ein Schwachsinn bzw. nicht notwendig.

[Zerf (Gast)]

Irgendwo wirst du ein ->next hinschreiben müssen, sonst wird keine Liste 
draus.

[Vlad T. (vlad_tepesch)]

Johannes M. schrieb:
> Mit diese malloc(sizeof(List)) füge ich ja schon ein neues Element ein
> und diese Zeile mit
> list = list->next;
> ist ein Schwachsinn bzw. nicht notwendig.

trotzdem macht sich die Verpointerung nicht von allein.

Mein Tip:
Trenne Nutzdaten und Struktur!
KApsel das Listeninterface gescheit
Dann wird das ganze auch übersichtlich

Denke dir die Typdefs bitte selbst dazu

struct List
{
  ListElement* first;
  ListElement* last;
}


struct ListElement
{
  ListElement* next;
  void*        data;
}

/**
 * adds an element at the end of the list
 * @param list  the list to manipulate
 * @param data  pointer to the data to add
 */
void List_pushBack( List* list, void* data)
{
  ListElement* e = malloc(sizeof(ListElement));
  if(list->last != 0) {
    list->last.next = e;
  }else{
    list->first = e;
  }
  e->next = 0;
  e->data = data;
  list->last = e;
}

/**
 * adds an element at the front of the list
 * @param list  the list to manipulate
 * @param data  pointer to the data to add
 */
void List_pushFront( List* list, void* data)
{
  ListElement* e = malloc(sizeof(ListElement));
  e->next = list->first;
  e->data = data;
  if(list->last == 0) {
    list->last = e;
  }
  list->first = e;
}


/**
  * frees the memory of all *following (next)* list elemnt.
  * @param le           pointer to listelement
  *                     if the first listelement of a list should be deleted
  *                     the list pointer can be casted to an Listelement*
  * @param deleteContent if true also the data of the list elemnt will be freed
  *                     obviously this only work on plain data structures with no
  *                     further pointer
  */
ListElement* List_deleteNextItem( ListElement* le , bool deleteContent)
{
  if(ls->next)
  {
    ListElement* n = ls->next.next;
    if(deleteContent)
    {
      free(ls->next.data);
    }
    free(ls->next);
    ls->next = n;
  }
  return ls->next;  
}

/**
  * frees the memory of all list elemnts.
  * @param list          pointer to list
  * @param deleteContent if true also the data of each list elemnt will be freed
  *                     obviously this only work on plain data structures with no
  *                     further pointer
  */
void List_deleteAll(List* list, bool deleteContent)
{
  while( List_deleteNextItem((ListElement*) list, deleteContent) )
  {};
}




List myList = {0,0};
PayLoad* filedata;

while( filedata = ReadDataFromFile(...) )
{
  List_pushBack(&myList, filedata)
}

hier das ganze in c++

#include <list>

std::list<PayLoad*> myList;  // wobei man hier normalerweise keinen Pointer nehmen würde.

PayLoad* filedata;

while( filedata = ReadDataFromFile(...) )
{
  List_pushBack(&myList, filedata)
}

[google (Gast)]

http://www.google.de/#sclient=psy-ab&hl=de&source=hp&q=einfach+verkettete+liste+c+beispiel&pbx=1&oq=einfach+verkettete+liste+c&aq=1&aqi=g2g-v2&aql=&gs_sm=e&gs_upl=0l0l1l95l0l0l0l0l0l0l0l0ll0l0&bav=on.2,or.r_gc.r_pw.,cf.osb&fp=800eb84fae61de39&biw=1219&bih=744

[Zerf (Gast)]

Perlen vor die Säue...

[google (Gast)]

nur hinfummeln heisst nicht verstehen. wenn er lesen kann, wird 's noch 
was :-)

[Johannes M. (Gast)]

Danke, Vlad Tepesch, eine super Erklärung und
@google (Gast)
Ja ich werde versuchen lesen zu lernen ;)

[Karl H. (kbuchegg)]

Johannes M. schrieb:
>

List *readInput(char *name_of_file, int *error_code,
...
> }

Entschuldige.
Aber das ist doch alles Mist!


Trenne die Dinge auf!

Mach dir eine Funktion, der du eine Datenstruktur übergibst und die 
diese Datenstruktur vom File befüllt.
Es ist nicht Aufgabe dieser Funktion, dieses Datenelement dann auch noch 
in die Liste einzuhängen! Das geschieht an einer anderen Stelle!

Du schreibst da endlos lange Funktionen und dann wunderst du dich, wenn 
du den Überblick verlierst.
Ich hab dir doch beim letzten mal schon so ungefähr eine sinnvolle 
Struktur gegeben. Ich mach das doch nicht zum Spass und weil draussen 
das Wetter so schön ist.

Eines der 'Geheimnisse' der Programmierung besteht darin, dass man sich 
Struktur in den Code bringt. Struktur im Sinne von 'Aufteilung in 
Teilprobleme und jedes Teilproblem wird zu einer Funktion'. So kann man 
das Biest "Unübersichtlichkeit" bekämpfen und unter Kontrolle bringen. 
Aber doch nicht, indem man alles in möglichst eine einzige Funktion 
reinquetscht. Und dann auch noch mehrfach (wie zb das Einlesen eines 
Strings).

Gerade Neulinge glauben oft: Ja, aber wenn ich das jetzt erst mal in 
Teilfunktionen aufteile, dann brauch ich so lang bis ich fertig 
programmiert habe.
Das genaue Gegenteil ist der Fall! Du brauchst 10-fach länger, wenn du 
NICHT gleich organisiert an die Dinge ran gehst. Denn du wirst die 
Übersicht verlieren. Das ist 100% sicher! So ein Wunderwuzzi bist du 
nicht, dass bei dir alles ganz anders ist, wie bei den restlichen 
weltweit 20-tausend Programmierer, die jetzt im Moment genau das gleiche 
vorhaben.