एक malloc'd लिंक्ड सूची को/से एक बाइनरी फ़ाइल

Question

से पढ़ना और लिखना मुझे एक कक्षा के लिए असाइनमेंट करने की आवश्यकता है। यह सी में एक साधारण फोनबुक ऐप है, और मुझे इसके साथ थोड़ा परेशानी हो रही है क्योंकि मुझे प्रोग्राम में कुछ नई चीजें उपयोग करने की ज़रूरत है और समय सीमा काफी तंग है।

मैंने चारों ओर देखा और कुछ जवाब पाये, लेकिन हर बार एक नया आया। :)

यह मेरा (सरलीकृत) कार्यक्रम है:

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); 
} 

मैं नगण्य भागों बाहर छोड़ दिया। अब मुझे पता है कि यह ज्यादा नहीं है, लेकिन मेरे वर्ग के नेता ने कहा कि मुझे डेटा स्टोर और पुनर्स्थापित करने के लिए बाइनरी फाइलों का उपयोग करना चाहिए। लेकिन अगर मैं फ्रेड और फेराइट का उपयोग करना चाहता हूं तो मुझे वास्तव में भ्रमित हो गया।

---

समाधान के लिए बहुत बहुत धन्यवाद! मुझे लगता है कि मैं अवधारणा को समझना शुरू कर देता हूं। प्रोग्राम अब डेटा संग्रहीत करता है (कम से कम मुझे लगता है कि यह करता है, क्योंकि फ़ाइल अधिक बढ़ती है क्योंकि फाइल अधिक बढ़ती है।) ताजा द्विआधारी फ़ाइल शुरू करते समय, प्रोग्राम अनुरोध करते समय डेटा को सही तरीके से प्रदर्शित करता है, लेकिन अगर मैं इसे बंद करता हूं, और उसी फ़ाइल को फिर से खोलें, कुछ भी तब नहीं होता जब यह संपर्कों को सूचीबद्ध करने का प्रयास करता है।

यहाँ (सरलीकृत फिर से, मैं वास्तविक काम में एक रिकॉर्ड में 10 विवरण) है खुला समारोह:

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; 
} 

और मुख्य() में, मैं का उपयोग करें:

start=open(db, start); 

घोषणा भाग:

record *start=NULL; 

कोई जवाब देता है तो फिर से धन्यवाद।

Answer 1

अपनी लिंक की गई सूची को फ़ाइल में लिखने के लिए, आप सूची के माध्यम से भाग सकते हैं और अपनी संरचना लिख ​​सकते हैं।

#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 आप fopen में wb मोड के साथ खोल सकते हैं एक फाइल है।

Answer 2

तो, उम्मीद है कि यह असाइनमेंट घर चलाएगा क्यों मैन्युअल रूप से धारावाहिक/deserializing एक भयानक विचार है (उद्योग में, इस तरह की चीज करने का असली तरीका स्वचालित कोड पीढ़ी जैसे protocol buffers) है, लेकिन इसके प्रयोजनों के लिए यह असाइनमेंट, आपको लिंक लिखने के बिना लिंक्ड सूची की सामग्री लिखनी होगी, और फिर जब आप deserialize करते हैं तो आपको लिंक को पुनर्निर्माण करने की आवश्यकता होगी, क्योंकि अगले पॉइंटर्स के पते को लिखना और पढ़ना गलत होगा सूची मैं।

Answer 3

* अगली पॉइंटर को फ़ाइल में छोड़कर सबकुछ लिखें, और अनुक्रम में उन्हें वापस पढ़ें।

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); 
} 

पढ़ते समय, डेटा को तब तक पढ़ें जब तक आप खाली रिकॉर्ड नहीं दबाते। आप इसके लिए फ्रेड() कर सकते हैं। बस नए रिकॉर्ड आवंटित करना याद रखें, इसे फ्रेड() के साथ पढ़ें और अगले पॉइंटर को अपडेट करें।