Wer sagt denn, dass du deswegen deine Daten in einen String kodieren musst? Du kannst doch genauso gut einen Zeiger auf ein struct in deiner Liste speichern, z.B.:
typedef struct eintrag
{
char* wort;
node* funde;
} eintrag;
typedef struct fund
{
char* dateiname;
int zeile;
} fund;typedef struct node
{
struct node* right; // Zeiger auf das Nachfolgerelement
struct node* left; // Zeiger auf das Vorgängerelement
void* content; // Für den Dateninhalt
node* liste;
} node;
typedef struct liste
{
char* dateiname;
int nodeCounter;
int lineCounter;
} liste;
...
typedef struct node
{
struct node* right; // Zeiger auf das Nachfolgerelement
struct node* left; // Zeiger auf das Vorgängerelement
void* content; // Für den Dateninhalt
} node;typedef struct node
{
struct node* right;
struct node* left;
void* content; //da kommt eintrag rein
} node;
typedef struct eintrag
{
char* wort;
node* funde; //Eine Liste aus Funden
} eintrag;
typedef struct fund
{
char* dateiname;
int zeile;
} fund;typedef struct node
{
struct node* right; // Zeiger auf das Nachfolgerelement
struct node* left; // Zeiger auf das Vorgängerelement
void* content; // Inhalt von contdef => Inhaltsdefinition von content.
} node;
typedef struct contdef
{
char* wort;
node* def; // Erweiterung für ein wort in der Liste
}contdef;
typedef struct def
{
char* dateiname;
char* zeile;
} def;
......
#include "Liste.h"
node* init_Liste()
{
node* n = (node*) malloc(sizeof(node));
n -> right = n;
n -> left = n;
//n -> content = NULL;
n -> contdef -> wort = NULL;
n -> dateiname = NULL;
n -> zeile = NULL;
return n;
}
...
node* anhaengen(node* list, void* neuer_String, void* dateiname, void* (*set)(void*), int counter)
{
node* kopf = list;
node* aktl_Elem = list;
contdef* neu_Elem = (contdef*) malloc(sizeof(contdef));
if(neu_Elem == NULL)
{
printf("\n Listenelement konnte nicht angelegt werden, da kein Speicher vorhanden ist! \n");
exit(1);
}
neu_Elem -> wort = (char*) set(neuer_String);
neu_Elem -> dateiname = (char*) set(dateiname);
//printf("conttmp: %s\n", (char*) (neu_Elem -> content) );
//! Neues Element zeigt mit linkem Zeiger auf aktuelles Element (Liste)
neu_Elem -> left = list;
//! Neues Element zeigt mit rechtem Zeiger auf rechten Nachbarn des Aktuellen Elements
neu_Elem -> right = list -> right;
//! Von aktuellem Element auf rechtes Zeigen und von rechtem Element auf mit left auf
neues Element zeigen
list -> right-> left = neu_Elem;
//! Von aktuellem Element mit right auf neues Element zeigen
list -> right = neu_Elem;
}Die Definitionen von contdef und def haben in Liste.h nichts verloren! Die Liste soll ja generisch sein. Wieso hast du den Typ von zeile auf char* geändert? Du willst doch eine Zeilennummer speichern, also passt der numerische Datentyp int besser.
Wiederum: die Funktion init_Liste soll generisch sein, also nichts davon wissen, welche Elemente in ihr gespeichert werden! Die Funktion sollte z.B. so aussehen:
node* init_Liste(void* content)
{
node* n = malloc(sizeof(node));
n -> right = n;
n -> left = n;
n -> content = content;
return n;
}char wort[] = "foo";
char dateiname[] = "foo.txt";
def* fund = malloc(sizeof(def));
fund->dateiname = dateiname;
fund->zeile = 42;
contdef* eintrag = malloc(sizeof(contdef));
eintrag->wort = wort;
eintrag->def = init_Liste(fund);
node* liste = init_Liste(eintrag);...
neu_Elem -> wort = (char*) set(neuer_String);
neu_Elem -> dateiname = (char*) set(dateiname);
//printf("conttmp: %s\n", (char*) (neu_Elem -> content) );
//! Neues Element zeigt mit linkem Zeiger auf aktuelles Element (Liste)
neu_Elem -> left = list;
//! Neues Element zeigt mit rechtem Zeiger auf rechten Nachbarn des Aktuellen Elements
neu_Elem -> right = list -> right;
//! Von aktuellem Element auf rechtes Zeigen und von rechtem Element auf mit left auf neues Element zeigen
list -> right-> left = neu_Elem;
//! Von aktuellem Element mit right auf neues Element zeigen
list -> right = neu_Elem;
......
node* kopf = list;
node* aktl_Elem = list;
contdef* neu_Elem = (contdef*) malloc(sizeof(contdef)); //! Speicher für neuen Knoten besorgen
//! Überprüfen, ob Speicher angelegt worden ist
if(neu_Elem == NULL)
{
printf("\n Listenelement konnte nicht angelegt werden, da kein Speicher vorhanden ist! \n");
exit(1);
}
neu_Elem -> wort = (char*) set(neuer_String);
neu_Elem -> dateiname = (char*) set(dateiname);
node* neu_Node = (node*) malloc(sizeof(node));
//printf("conttmp: %s\n", (char*) (neu_Elem -> content) );
//! Neues Element zeigt mit linkem Zeiger auf aktuelles Element (Liste)
neu_Node -> left = list;
//! Neues Element zeigt mit rechtem Zeiger auf rechten Nachbarn des Aktuellen Elements
neu_Node -> right = list -> right;
//! Von aktuellem Element auf rechtes Zeigen und von rechtem Element auf mit left auf neues Element zeigen
list -> right-> left = neu_Node;
//! Von aktuellem Element mit right auf neues Element zeigen
list -> right = neu_Node;Du vermischst hier schon wieder die Implementierung der generischen Liste und problemspezifischen Code. Das kann nicht vernünftig funktionieren. Ich versuche noch ein letztes mal damit bei dir durchzukommen: Implementiere die Liste unabhängig davon, welche Elemente sie speichert. Also kein wort oder dateiname oder zeile in der Implementierung der Listenfunktionen.
Dann würde sich doch aber ein Array aus ints viel besser eigen!? Abgesehen davon reicht es, genau eine Zeilennummer pro Eintrag speichern, denn:
Du hast den vorgeschlagenen Aufbau nicht ganz verstanden. Deine Hauptliste soll für jedes vorgekommene Wort einen Eintrag besitzen. Jeder Eintrag speichert jeweils 1. das Wort und 2. eine Liste mit den Vorkommnissen (Funde) dieses Wortes. Jedes Vorkommnis verzeichnet 1. den Dateinamen und 2. die Zeilennummer.
foo bar
foobar
foofoobar
foo[ # Liste von Einträgen
{ # Eintrag
wort: "foo",
funde: [ # Liste von Funden
{ dateiname: "foo.txt", zeile: 1 }, # Fund
{ dateiname: "foo.txt", zeile: 3 }, # Fund
{ dateiname: "bar.txt", zeile: 2 } # Fund
]
},
{ # Eintrag
wort: "bar",
funde: [ # Liste von Funden
{ dateiname: "foo.txt", zeile: 1 } # Fund
]
},
{ # Eintrag
wort: "foobar",
funde: [ # Liste von Funden
{ dateiname: "foo.txt", zeile: 2 }, # Fund
{ dateiname: "bar.txt", zeile: 1 } # Fund
]
}
]Abgesehen davon, dass das überhaupt nicht nötig ist (s.o.), verkomplizierst du die Sache mit einem String nur. Du kannst nicht einfach strcat aufrufen, ohne vorher entsprechend Speicher reserviert zu haben.
