[C++] Serializzazione

[_Claudio]

Per tutti i C++omani, come faccio a leggere e salvare da file un vettore di oggetti?
Ecco il codice:

vector<tipo> foo;

/* ... tramite un iteratore viene aggiunta marmaglia a foo */

ofstream salva (nomefile, ios::binary);
salva.write((char*)&foo, sizeof(foo));
salva.close();

ifstream carica (nomefile, ios::binary);
carica.read((char*)&foo, sizeof(foo));
carica.close();


Il problema è che tutto sembra funzionare ma invece non salva sul file tutto il contenuto di foo ma solo il riferimento al vettore foo grande 20byte.

[Tommo]

Questo è proprio un "dirty trick" ma funziona dato che vector garantisce la contiguità della memoria :D


salva.write( (char*)&(foo[0]), foo.size() * sizeof(foo[0]) );

[DanieleC88]

A parte il "dirty trick"... :D
Non puoi iterare sugli elementi e salvarli l'uno dietro l'altro?

ciao ;)

[_Claudio]

Questo è proprio un "dirty trick" ma funziona dato che vector garantisce la contiguità della memoria :D


salva.write( (char*)&(foo[0]), foo.size() * sizeof(foo[0]) );


Esatto ho pensato anche io un po' alla stessa cosa, cioè "bastonare" direttamente la memoria...
Ma c'è un problema però... finchè scrivo tutto bene, quando leggo come faccio a sapere quanti elementi sono stati salvati? Se uso foo.size() questo mi ritorna 0... è vuoto.

A parte il "dirty trick"... :D
Non puoi iterare sugli elementi e salvarli l'uno dietro l'altro?

ciao ;)

Sì... ma ha un costo non costante... meglio il dirty trick.

[_Claudio]

Risolto, bisogna maltrattare in malomodo la memoria, con un cast si assegna l'indirizzo iniziale in memoria del vector ad un puntatore a char, la dimensione si trova facendo dimensionedelfile/sizeof(tipo()) e si carica carattere per carattere dal file alla memoria puntata dal char che ad ogni lettura incrementa.

[Tommo]

E' più facile di così, basta "avvertire" il vettore che dovrà contenere n elementi usando i costruttori di preallocazione.

uint bytesize = ...
uint elements = bytesize/sizeof(T);

vector<T> foo( elements );

salva.write( (T*)&(foo[0]), bytesize );


In questo modo ci sono solo costi costanti :read:

[_Claudio]

E' più facile di così, basta "avvertire" il vettore che dovrà contenere n elementi usando i costruttori di preallocazione.

uint bytesize = ...
uint elements = bytesize/sizeof(T);

vector<T> foo( elements );

salva.write( (T*)&(foo[0]), bytesize );


In questo modo ci sono solo costi costanti :read:

Per quanto riguarda il salvataggio sì, è possibile farlo con costo costante, per il caricamento invece a quanto pare non è possibile caricare direttamente tutto il vector e la soluzione più veloce è farlo carattere a carattere agendo a basso livello.
Esiste solo una scalcinata funzione get nell'ifstream per la lettura di dati non formattati che però legge necessariamente solo char* a basso livello.

Esistono anche gli streambuf, ma sinceramente non ho capito molto come usarli, ho capito perchè esistono ma non c'è uno straccio di linea di codice che li spiega se non alcuni esempi di buona programmazione che riportano del codice scritto tenendo in mente le funzionalità dietro le quinte di questi streambuf... qualcuno può essermi di illuminazione?

[Tommo]

No aspe mi so confuso, nel codice intendevo proprio read :D
Write è rimasto per sbaglio... non capisco che intendi, dovrebbe funzionare!

[_Claudio]

Hai proprio ragione, funziona tutto molto bene, bisogna passare un po' scomodamente da char * (d'altronde non vi è possibilità di serializzare o usare tipi generici).

Avevo maldestramente ignorato l'esistenza di una funzione speculare a write (read), basta solo acquisire la dimensione del file, allocare abbastanza elementi nel vector e poi leggere tutto in un colpo solo con una read ben assestata.

Grazie 1000 Tommo!!!