salviamo la gerarchia

[killalot]

Dunque, questo dovrebbe essere un problema abbastanza comune che però non viene nemmeno sfiorato in tutti i libri di programmazione ad oggetti che ho letto/consultato.
In pratica si tratta di salvare su disco tutte le informazioni sulla gerarchia di oggetti che risiedono in memoria durante l'esecuzione del programma.
In genere non faccio altro che inserire nella classe root un metodo saveData() o giù di lì che discende in maniera scimmiesca tutta la gerarchia e richiede ai singoli oggetti le informazioni.
Ora, mi rendo conto io stesso che è un metodo abbastanza troglodita :D , se non altro perchè ogni volta che aggiungo una classe al progetto devo andare a modificare il tutto.
Quindi mi chiedevo se esiste una tecnica più furba, applicabile possibilmente sia a c++ che java o a qualsiasi altro linguaggio ad oggetti... qualcuno ne sa qualcosa?? :p

[Kleidemos]

mi faresti un esempio di quello che usi?

[killalot]

Dunque ti faccio un esempio che riguarda più o meno la roba su cui lavoro. Diciamo che c'e' un programma per l'analisi della struttura chimica delle molecole, scritto in c++. Ora, quando ho iniziato a scriverlo, la mia conoscenza della logica ad oggetti non era proprio cristallina e quindi diciamo che c'e' qualche difetto di progettazione :D .
In pratica ho una classe principale Project che contiene una serie di array a dimensione variabile, (sono dei vector<> ma potrebbero essere benissimo delle ArrayList in java o qualche altro tipo di classe container) che rappresentano le varie sostanze, la lista delle proprietà chimico-fisiche, nonchè una lista di algoritmi che mettono in correlazione le proprietà con la struttura.
Quindi, per salvare i dati su disco, nella classe Project ho inserito un metodo che iterativamente scorre tutti gli array (strutture, proprietà, etc), e per ogni oggetto contenuto nell'array fa la stessa cosa con le strutture dati nidificate nell'oggetto stesso (ad esempio ogni oggetto di tipo struttura contiene un array di oggetti di tipo "atomo" e uno di tipo "legame").
La cosa tutto sommato funziona, anche perchè diciamo che la complessità del progetto non è elevata, il fatto è che ogni volta che si operano dei cambiamenti nelle classi sottostanti occorre andare a modificare i metodi saveData()/loadData() della classe project, cosa che, oltre ad essere poco elegante, viola probabilmente anche qualche regola della programmazione ad oggetti :D .
Non so se mi sono spiegato abbastanza chiaramente... :p

[cionci]

Originally posted by "killalot"

Quindi mi chiedevo se esiste una tecnica più furba, applicabile possibilmente sia a c++ che java o a qualsiasi altro linguaggio ad oggetti... qualcuno ne sa qualcosa?? :p
Se i dati non sono dichiarati dinamicamente e non ci sono puntatori in C++ basterebbe fare una write(this, sizeof(*this)); In Java non dovrebbe funzionare...

Magari in Java esiste già qualcosa riguardo alla serializzazione delle classi...
Comunque il tuo metodo credo che sia valido.. Cioè fare una funzione virtuale in ogni classe della gerarchia che richiama la stessa funzione sulla/e classe/i da cui deriva e successivamente salva i dati relativi alla sua istanza eventualmente presenti nella classe...

[Kleidemos]

capisco!
Aspetto risposte perche interessato ;)

[killalot]

Originally posted by "cionci"


Comunque il tuo metodo credo che sia valido.. Cioè fare una funzione virtuale in ogni classe della gerarchia che richiama la stessa funzione sulla/e classe/i da cui deriva e successivamente salva i dati relativi alla sua istanza eventualmente presenti nella classe...

Si, in effetti adesso come adesso sto usando proprio questo tipo di approccio. Mi chiedevo però se esiste un metodo più furbo per fare in modo che ogni oggetto sappia già i dati che contiene, sia a livello di attributi "semplici" che di dati tipo "array", in modo da non essere obbligati a ridefinire per ogni classe la funzione che salva i dati e poterne scrivere una "universale" definita nella classe root della gerarchia.
Non so, forse è una fissazione dovuta alla proverbiale prigrizia del programmatore :D

[Kleidemos]

...tu intendi una funzione nella superclasse che salvi , senza essere ridefinita nelle derivate, tutto quello che ti serve?

[cionci]

Originally posted by "killalot"

La cosa tutto sommato funziona, anche perchè diciamo che la complessità del progetto non è elevata, il fatto è che ogni volta che si operano dei cambiamenti nelle classi sottostanti occorre andare a modificare i metodi saveData()/loadData() della classe project, cosa che, oltre ad essere poco elegante, viola probabilmente anche qualche regola della programmazione ad oggetti :D .
Non so se mi sono spiegato abbastanza chiaramente... :p
Ti faccio un esempio:

class atomo
{
... //dati privati
public:
virtual void SaveData(ofstream &fs);
virtual void LoadData(ifstream &fs);
void SaveData();
void LoadData();
};

void atomo::SaveData()
{
ofstream file(FILENAME); //non so come tu voglia fare per ottenere il filename
SaveData(file);
file.close();
}

void atomo::SaveData(ofstream &fs)
{
...//Salvi i dati nel file
}

void atomo::LoadData()
{
ifstream file(FILENAME); //non so come tu voglia fare per ottenere il filename
LoadData(file);
file.close();
}

void atomo::LoadData(ifstream &fs)
{
...//Carichi i dati nella classe
}

class molecola: public atomo
{
... //dati privati
public:
virtual void SaveData(ofstream &fs);
virtual void LoadData(ifstream &fs);
};

void molecola::SaveData(ofstream &fs)
{
atomo::SaveData(fs); //salvo i dati della classe base
...//Salvi i dati nel file
}

void molecola::LoadData(ifstream &fs)
{
atomo::LoadData(fs); //carico i dati della classe base
...//Carichi i dati nella classe
}

class project
{
vector<molecola> m;
vector<atomo> a;
public:
virtual void Save();
virtual void Load();
};

void project::Save()
{
for(int i=0; i<m.size(); ++i)
m[i].SaveData(); //puoi fare in questo modo

ofstream file(FILENAME); //non so come tu voglia fare per ottenere il filename
for(int i=0; i<a.size(); ++i)
a[i].SaveData(file); //oppure in questo modo
file.close();
}

void project::Load()
{
for(int i=0; i<m.size(); ++i)
m[i].LoadData(); //puoi fare in questo modo

ifstream file(FILENAME); //non so come tu voglia fare per ottenere il filename
for(int i=0; i<a.size(); ++i)
a[i].LoadData(file); //oppure in questo modo
file.close();
}

In questo modo se fai una modifica in qualsiasi classe dovrai rimettere mano solamente alla sezione di salvataggio e caricamento dei dati di quella classe aggiungendo id ati modificati...

[killalot]

Originally posted by "cionci"


Ti faccio un esempio:



In questo modo se fai una modifica in qualsiasi classe dovrai rimettere mano solamente alla sezione di salvataggio e caricamento dei dati di quella classe aggiungendo id ati modificati...

accidenti :p
grazie... in effetti è quello che attualmente tenta di fare il lio programma, in una maniera un po' più confusa :D .
Credo che in fin dei conti sia la cosa più ragionevole, dato che permette di aggiungere al programma tutte le funzionalità necessarie senza rimettere mano ogni volta al codice base, mantendendo al tempo stesso il controllo sui dati che vanno effettivamente salvati all'interno di ogni oggetto.
In effetti l'idea di un metodo "generale" all'interno della classe root che percorra automaticamente tutta la gerarchia degli oggetti non è poi così flessibile...
in ogni caso appena ho un po' di tempo mi metto al lavoro:D
intanto grazie a tutti

[/\/\@®¢Ø]

La serializzazione del codice in Java e' relativamente semplice (basta implementare una interfaccia) visto che tutti i problemi vengono poi gestiti dalla Virtual Machine. In C++ il discorso e' decisamente piu' complicato. Per il salvataggio il problema principale e' che devi distinguere tra campi normali e puntatori, e il linguaggio non offre strumenti di introspezione per chiedere "dimmi quali campi e quali puntatori ha quella classe" per fare un salvataggio ricorsivo. La soluzione e' quindi quella mostrata da cionci, in cui ogni oggetto implementa una funzione di salvataggio virtuale da ridefinire. Per la lettura il problema e' ancora piu' grosso. Spesso infatti tu hai voglia di caricare solo un oggetto di cui sai la classe base, ma non la classe specifica. Un metodo per il caricamento tradizionale non va quindi bene.
Ad esempio

class A{
public:
virtual void do_something(){ /*...*/ }
};
class B:public A
{
public:
void do_something() { /* ... */ }
};

A* a = "Leggi da stream l'oggetto";
a->do_something();

L'ideale sarebbe poter caricare un oggetto di tipo B "senza accorgersene".
In questo caso l'unica possibilita' e' creare una classe di appoggio che provveda a salvare il nome effettivo della classe prima dei chiamare il metodo ridefinito. Al momento della lettura poi questo nome viene letto e chiamato il costruttore adatto.Tempo fa ho fatto una cosa del genere e funzionava decorosamente.
Alternativa piu' semplice.... cercare qualcosa su internet :D. Materiale commerciale di sicuro ce n'e', gratuito non so.

[killalot]

Originally posted by "/\/\@®¢Ø"


L'ideale sarebbe poter caricare un oggetto di tipo B "senza accorgersene".
In questo caso l'unica possibilita' e' creare una classe di appoggio che provveda a salvare il nome effettivo della classe prima dei chiamare il metodo ridefinito. Al momento della lettura poi questo nome viene letto e chiamato il costruttore adatto.


Chiaro. Forse un approccio alternativo potrebbe essere quello di utilizzare un formato dati basato su XML con relativo parser... sto sparando perchè non me ne intendo un granchè di XML :D

[/\/\@®¢Ø]

Il problema e' proprio il parser, visto che sintassi piu' complicate di quella del C++ non se ne trovano :D.
Una volta che si ha la lista dei campi da salvare e dei puntatori generare il codice non e' una impresa impossibile. Si potrebbe pure stabilire un back-end diverso a seconda delle esigenze (salvataggio in xml per scambiarsi i dati, byte "grezzi" per migliori performances etc..)