Newsgroup: it.comp.lang.c++
Titolo: salvare oggetti su file...

Ciao,
lo so che puo sembrare stupida questa domanda, ma ... è possibile salvare 
oggetti su file senza dover passare per una loro conversione manuale in 
formato ASCII, insomma un qualcosa di simili ad un "ObjectOutputStream" di 
Java?
Nella documentazione e nei libri che ho non sono riuscito a trovare nulla 
di simile in C++, ma prima di cimentarmi a fare una procedura per salvare 
in ASCII, ho preferito chiedere consiglio a chi ha più conoscenze ed 
esperienza di me nel campo del C++.
Grazie a tutti.
Checco

 ha scritto nel messaggio
news:oprugr8p...@news.tin.it...

si puoi salvare l'oggetto senza problemi su tutti gli stream binari, ma cmq
ci vuole un certo controllo per il salvataggio e per il caricamento di tali
oggetti soprattutto se contengono puntatori ecc ... cioe' dovresti cmq
crearti un metodo di salvataggio nella classe che dia in output solo le
infrmazioni utili e non puntatori inutili per il salvataggio ;-)
disolito implementi per io testo i metodi friend di overloading operator >>
e <<, per il binario potresti pensare ad altri metodi, o sempre all'interno
degli stessi fare il test se lo stream che ti arriva e' di testo o binario
... e cosi' decidere che cosa buttare o prendere su di esso ...
cmq penso che qualcuno un po' piu' esperto ti rispondera' alla fine
io penso che l'unico casino che possa succedere e' che cerchi di salvare una
gerarchia di classi che non hanno un modo di estrarre le loro info, e se
andate a copiare brutalmente si ottiene solo un riso e fagioli di puntatori
inutili ...
ciao

 ha scritto nel messaggio
news:oprugr8p...@news.tin.it...


Java?
non è una domanda stupida..
http://www.parashift.com/c++-faq-lite/serialization.html
sbirish.

 Java?
Non so sinceramente come funzioni la ObjectOutputStream di Java, ma
per come ne intuisco l'utilita' puoi facilmente ricrearla con una
classe che eredita da fstream... qui sfruttando sizeof e un cast a
unsigned char* ti butti l'obj su file in binario....
Hola! :)))
Digusting Angel

 esperienza di me nel campo del C++.
Puoi certamente scrivere e rileggere dati in formato binario con gli
strumenti presenti nella libreria standard (iostream o cstdio); questo
pero' presuppone di sapere cosa stai leggendo. Non esiste un
meccanismo standard di serializzazione, che ti permetta cioe' di
ricostruire una struttura dati salvata su file da zero.
Ciao,
Nicola

Vi ringrazio a tutti :)
Ho fatto una prova e funziona bene (per ora la classe di prova è molto 
semplice, in futuro si vedrà).
Continuo sempre di più a credere che si impara più da chi ha esperienza che 
da 1000 libri (e soprattutto più velocemente).
ciao,
Checco
------------------------PROVA.CPP----------------------------
#include <iostream>
#include <stdlib.h>
#include <fstream>
using namespace std;
class prova
{
	public:
		// class constructor
		prova(int nx, int ny) { x = nx; y = ny;}
		prova(){};
 
		int getX() {return x;}
 
	private:
	    int x;
	    int y;
};
int main(int argc, char *argv[])
{
    prova pippo(10,20);
    prova pluto;
    // scrittura
    ofstream os("prova.dat", ios::out|ios::binary); os.write((const char*) 
&pippo, sizeof(prova));
    os.close();
    // lettura
    ifstream is("prova.dat", ios::in|ios::binary);
    is.read((const char*) &pluto, sizeof(prova));
    is.close();
    // verifica
    cout << pluto.getX() << endl;
    system("PAUSE");	
    return 0;
}

 is.read((const char*) &pluto, sizeof(prova));
          ^^^^^^^^^^^^^
Nel taglia e incolla ho lasciato un vecchio errore;
err.corr.:
is.read((char*) &pluto, sizeof(prova));

 Checco
Ciao Checco, io fossi in te darei un occiata anche agli altri 999
libri.....:):)
1) Davvero pensi che per il fatto di essere riuscito sulla tua piattaforma a
fare una cosa del genere con una classe cosi' semplice, questa sia la regola
universale per la serializzazione in c++...:):)
e se invece la tua classe fosse stata la seguente:
class prova
{
public:
// class constructor
prova(string nx, string ny): x (nx),y(ny) {}
prova(){};
string getX() {return x;}
private:
    string x;
    string y;
};
pensi che la cosa sarebbe funzionata ugualmente?
2) In C++ gli oggetti e preferibile costruirli come sta scritto sui libri.
Ciao Ivan


Ciao,
Checco.

 system("PAUSE");	 return 0; }
Ma perchè quando incollo mi cambia la tabulazione !!!!! @#@#@[]@[]@#@][@]


 punto(){};
Ti sei chiesto perche' funziona? Dire che funziona non e' nulla,
l'importante e' sapere il perche' funziona, ......e tu sei qui' senza
perche', quindi senza potere....:):)
Scusa mi sono fatto prendere la mano, ho visto troppe volte Matrix
reloaded......:):)
Ciao Ivan


No, non funziona. Nemmeno nel tuo esempio.
Visto che stai studiando il C++, ti sconsiglio di passare a un nuovo
argomento finché non avrai compreso perché questa "soluzione" non funziona.
(La questione è stata discussa tante di quelle volte in questo newsgroup,
che non mi pare il caso di ripetere per l'ennesima volta le stesse cose.
GIYF.)
Max

 No, non funziona. Nemmeno nel tuo esempio.
Si, ho visto che non funziona. Penso che String usi un puntatore, nel mio 
caso funziona perchè ancora punta allo stesso oggetto in memoria, basta 
aggiungere:
[...]
// modifica dell'oggetto iniziale
pippo.set((punto ("11","21")), (punto ("31","41")));
ifstream is("prova.dat", ios::in|ios::binary);
is.read((char*) &pluto, sizeof(linea));
is.close();
ed il tutto non funziona più ;).
Ma si impara anche sbagliando, comunque l'oggetto che devo salvare contiene 
dati primitivi come float ed int, quindi il tutto può essere ancora utile 
per me (è vero che sto imparando ma mi serve per scrivere la tesi, quindi 
devo imparare ed applicare).
Ciao,
Checco.

 dati primitivi come float ed int, quindi il tutto può essere ancora utile
Allora non parliamo di serializzazione, ma di salvare dati su un file.
Ivan

 Ivan
Effettivamente forse ho sbagliato a citare la classe java 
"ObjectOutputStream" che effettivamente esegue una serializzazione da 
libreria. Il mio problema è più semplice e si tratta proprio di salvare su 
file sequenze di dati correlati, senza dover però fare tutto manualmente 
pezzo pezzo, per poi magari rimodificare tutto il codice solo perchè mi 
serviva anche un altro dato.
Se c'era una funzione di libreria standard c++ per serializzare (quindi 
scritta da chi ha più di 20gg di esperienza ;) ) , questo avrebbe risolto 
automaticamente anche il mio problema. Ho trovato librerie free su internet 
che eseguono la serializzazione, ma naturalmente non sono standard.
Quindi per ora tralascio la serializzazione ad un prossimo futuro e mi 
accontento di quello che ho imparato per salvare i miei dati ed andare 
avanti con la tesi.
ciao e grazie,
Checco.
P.S.
Certo che non sarebbe male includere nell'ISO c++ una classe per 
serializzare :)

 serializzare :)
La serializzazione in c++, non ha molto senso, o per lo meno non come in
java: quello e' byte code, ossia indipendente dalla piattaforma, non
esistono puntatori, e il concetto di serializazione e' "scolpito" nella JVM,
in c++ tu hai byte, endian-ordering, opcode-platform specific  ecc... che
praticamante rendono se non impossibile, impensabile un tale  sforzo
sovrumano...:):)
Ivan

 serviva anche un altro dato.
XML è la soluzione di tutti i problemi. 
-- 
Luc.

 ha scritto nel messaggio
news:MPG.19b66c874...@tornado.fastwebnet.it...

Soluzione ad alcuni problemi.
I formati binari sono più efficienti in quanto meno verbosi.
Alberto

 I formati binari sono più efficienti in quanto meno verbosi.
Raramente si ha bisogno di efficienza "spinta" in occasione di 
load/save. 
-- 
Luc.

 load/save.
Te lo immagini IIOP implementato in XML,minimo una passata di parser  ad
ogni metodo invocato....:):)
Gia' questi protocolli sono dei bradipi con dei formati propietari,
figuriamoci in XML.....
Ivan

 Te lo immagini IIOP implementato in XML
Non è il ns. caso, mi sembra... 
-- 
Luc.


A me invece sembra propio di si, visto che nelle remote invocation la
serializzazione e' di casa :)
Ivan

 serializzazione e' di casa
Francesco deve implementare remote invocation? 
-- 
Luc.

> Francesco deve implementare remote invocation?
Ora non ne ha bisogno, pero' se scrive del codice in maniera intelligente,
se lo ritrovera' anche per gestire quei casi,senza dover sbattersi a rifare
tutto da capo solo perche' al momento non ci aveva pensato.......
Magari tu sei uno di quelli che scrive il suo codice pensando esclusivamante
al problema specifico? :)
Ivan

 al problema specifico? :)
Certo, paraocchi e via! :-PPP
PS: salvare un file di 100 byte o di 300 byte non ti cambia molto la 
vita con l'hardware di oggi... Anche se ne devi salvare 100 di oggetti. 
-- 
Luc.

 vita con l'hardware di oggi... Anche se ne devi salvare 100 di oggetti.
Ok, e' per spedirli in rete in un invocazione remota, la vita te la cambia?
Oltre ad avere una mole di dati triplicata, avresti anche l'onere della
parsificazione XML, che ricordiamolo ......ci fa risparmiare 5 centesimi a
transazione.......:):)
Ivan

 esclusivamante al problema specifico? :)
C'è chi dice sia una buona soluzione:
http://www.extremeprogramming.org
-- 
Gerolamo

 transazione
Ah... ho capito dove vuoi arrivare a parare... Direi di chiudere il 
thread allora. 
-- 
Luc.

Ti consiglio di dare uno sguardo anche a alt.comp.lang.learn.c-c++ .
Ciao!