[C++] File binari

[fedee91ee]

Salve!
Vorrei chiedervi un piccolo aiutino!
Praticamente ho implementato una classe libro e ho inserito gli oggetti della classe all'interno di una pila dinamica. Ora il mio problema sta nel stampare l'intera pila su file binario. In realtà io l'ho fatto in un modo, ma non sono sicura che sia giusto (anche se funzione xD), ma soprattutto non so se si possa ottimizzare ed è proprio per questo che chiedo il vostro aiuto.
Praticamente ho creto una funzione che tratta l'oggetto della classe e poi una funzione per la pila che richiama la precedente. Ora posto il codice:

Classe Libro:

const int dim=50;

class Libro{
      private:
             char codice[dim];
             char* titolo;
             int num_pagine;
             int anno_pubbl;
      public:
             Libro(const char* c="", const char* t="", const int num_p=0, const int anno_p=0);
             Libro(const Libro &);
             ~Libro(){delete [] titolo;}
             const Libro & operator=(const Libro&);
             void set_titolo(char*);
             char* get_titolo()const{return titolo;}
             bool check_copyright(const Libro &);
             friend ostream & operator <<(ostream&, Libro&);
             friend istream & operator >>(istream&, Libro&);
             void scrivisufile(ofstream& os);
             void leggidafile(ifstream& is);
      };

Funzione stampa e leggi della classe:

void Libro:: scrivisufile(ofstream& os){
     
    
     
     int n= dim*sizeof(char);
     os.write((const char*)(&codice),n);
     os.write((const char*)(&titolo), strlen(codice)+1);
     os.write((const char*)(&num_pagine),sizeof(int));
     os.write((const char*)(&anno_pubbl), sizeof(int));
     
}

void Libro:: leggidafile(ifstream& is){
     
     
     int n= dim*sizeof(char);
     is.read((char*)(&codice),n);
     is.read((char*)(&titolo), strlen(codice)+1);
     is.read((char*)(&num_pagine),sizeof(int));
     is.read((char*)(&anno_pubbl), sizeof(int));
     cout<<codice<<titolo<<num_pagine<<anno_pubbl<<endl;
     
     
}

Pila dinamica:

typedef Libro E;
struct Record;
typedef Record* Pila;


struct Record{
       E elem;
       Pila next;
};

Funzioni stampa e leggi per la pila

void stampafile(const Pila& p){
     
     ofstream os;
     os.open("binario", ios::binary);
     
     Record * ptr;
     ptr=p;
     while(ptr)
     {
        ptr->elem.scrivisufile(os);
        ptr=ptr->next;
     }   
     
     os.close();
     
}

void leggifile(const Pila& p){
     
     ifstream is;
     is.open("binario", ios::binary);
     
     Record * ptr;
     ptr=p;
     while(ptr)
     {
        ptr->elem.leggidafile(is);
        ptr=ptr->next;
     }   
     
     is.close();
}

Sembrano funzionare però visto che sono alle prime armi vi chiedo se possono essere ottimizzate o vanno bene così. Grazie in anticipo per l'aiuto!

[fedee91ee]

Nessuno potrebbe aiutarmi?

[starfred]

Ciao, il mio consiglio è: meno puntatori, più oggetti. Al posto di

char codice[dim];
char* titolo;

utilizza string.

Quando scrivi su file o in generale quando stai utilizzando diversi tipi di dato da formattare su stringhe utilizza ostringstream. Viceversa per "tornare indietro" utilizza istringstream. Così eviti di dover dimensionare il tutto (sizeof, strlen etc.)

Stesso ragionamento per la pila, puoi utilizzare tranquillamente vector, map, list etc. etc.
L'approccio non è più efficiente ma sicuramente ti eviterà parecchi memory leak.

Inoltre nessuno ti vieta di utilizzare una classe al posto della struct Record.

I typedef come li hai utilizzati tu non aiutano alla comprensibilità del codice, anzi la complicano.

Poi non saprei... non c'è il codice del primo costruttore ma dalla definizione non promette nulla di buono. char* c="" è sbagliato come anche const char* t="" forse volevi fare =NULL ?

Anche il distruttore mi ispira pochissima fiducia...

Spero di averti dato qualche spunto di riflessione. Ciao