Lesen und Schreiben einer Malloc'd-Liste von/zu einer Binärdatei

Question

Ich muss eine Zuordnung für eine Klasse machen, die ich nehme. Es ist eine einfache Telefonbuch-App in C, und ich habe ein wenig Probleme damit, da ich einige neue Sachen im Programm verwenden muss und der Abgabetermin ist ziemlich eng.

Ich schaute mich um und fand einige Antworten, aber jedes Mal kam ein neues auf. :)

Dies ist mein (vereinfachte) Programm:

typedef struct record 
{ 
    char fname[31]; 
    char lname[31]; 
    char tel[21]; 
    struct record *next; 
} record; 


record *new_entry(record *first, char *fname, char *lname, char *tel) 
{ 
    record *new; 
    new=(record*) malloc(sizeof(record)); 
    strcpy(new->fname, fname); 
    strcpy(new->lname, lname); 
    strcpy(new->tel, tel); 
    new->next=first; 
} 


void fileopen (char *db_file) 
{ 
    FILE *fp; 

    fp=fopen(db_file, "rb"); 
    if (fp==NULL) 
    { 
     fp=fopen(db_file, "wb"); 
     fclose(fp); 
     fp=fopen(db_file, "r+b"); 
    } 
} 



int main 
{ 
char db[51]; 
record *next = NULL; 

printf("File:   "); scanf("%s, db); 
fileopen(db); 
printf("First name:  "); scanf("%s", fname); 
printf("Last name:  "); scanf("%s", lname); 
printf("Phone number: "); scanf("%s", tel); 
first=new_entry(*first, fname, lname, tel); 
} 

verließ ich die unwesentlichen Teile aus. Jetzt weiß ich, dass es nicht viel ist, aber mein Klassenleiter sagte, ich sollte Binärdateien verwenden, um die Daten zu speichern und wiederherzustellen. Aber ich bin wirklich verwirrt, wenn ich Fread und Fwrite benutzen soll.

---

Vielen Dank für die Lösung! Ich denke, ich beginne das Konzept zu verstehen. Das Programm speichert jetzt die Daten (Zumindest denke ich es, weil die Datei wächst, während ich weitere Daten hinzufüge.) Beim Starten einer neuen Binärdatei zeigt das Programm die Daten korrekt an, wenn ich sie anfordere, aber wenn ich sie schließe, und die gleiche Datei erneut öffnen, passiert nichts, wenn es versucht, die Kontakte aufzulisten.

Hier ist die (wieder vereinfacht, ich habe 10 Details in einem Datensatz in der aktuellen Zuordnung) offen Funktion:

record *open (char *db_file, record start) 
{ 
    FILE *fp 
    record *temp = start; 
    fp=fopen(db_file, "rb"); 
    while (fread(temp, sizeof(rekord), 1, fp)>0) 
    { 
     fread(temp->fname, sizeof temp->fname, 1, fp); 
     fread(temp->lname, sizeof temp->lname, 1, fp); 
     fread(temp->tel, sizeof temp->tel, 1, fp); 
    temp=temp->next; 
    } 
    fclose(fp); 
    return temp; 
} 

Und in main(), die ich benutze:

start=open(db, start); 

Die Erklärung Teil:

record *start=NULL; 

Danke nochmal wenn jemand antwortet.

Answer 1

Um Ihre verknüpfte Liste in eine Datei zu schreiben, können Sie die Liste durchlaufen und Ihre Struktur schreiben.

#include <stdio.h> 

record *it = first; 

while (it != NULL) { 
    fwrite (it->fname, sizeof it->name, 1, stream); 
    fwrite (it->lname, sizeof it->lname, 1, stream); 
    fwrite (it->tel, sizeof it->tel, 1, stream); 
    it = it->next; 
} 

stream ist eine Datei, die Sie mit wb Modus in fopen öffnen können.

Answer 2

Also, hoffentlich wird diese Aufgabe nach Hause fahren, warum manuelle Serialisierung/Deserialisierung ist eine schreckliche Idee (in der Branche ist die reale Art, so etwas durch automatische Code-Generierung wie protocol buffers zu tun), aber für die Zwecke Bei dieser Zuweisung müssen Sie den Inhalt der verknüpften Liste schreiben, ohne die Verknüpfungen zu schreiben, und dann müssen Sie die Verknüpfungen bei der Deserialisierung rekonstruieren, da es inkorrekt wäre, einfach die Adressen der nächsten Zeiger zu schreiben und zu lesen In der Liste.

Answer 3

Schreiben Sie alles mit Ausnahme des * nächsten Zeigers in die Datei und lesen Sie sie nacheinander aus.

void write_book(const record *start) { 
    FILE *f; 
    record end; 
    memset(end,0,sizeof(struct record)); 
    f = fopen("foo","wb"); 
    for(;start != NULL; start = start->next) { 
    fwrite(start->fname, 31, 1, F); 
    fwrite(start->lname, 31, 1, F); 
    fwrite(start->tel, 21, 1, F); 
    fwrite(end->next, sizeof(void*), 1, F); 
    } 
    memset(end,0,sizeof(struct record)); 
    fwrite(end, sizeof(struct record),1,F); 
    fclose(f); 
} 

Lesen Sie beim Lesen die Daten, bis Sie den leeren Datensatz treffen. Sie können dafür fire(). Denken Sie daran, einen neuen Datensatz zuzuweisen, lesen Sie ihn mit fread() und aktualisieren Sie den nächsten Zeiger.