Newsgroup: it.comp.lang.c
Titolo: Chiedo consiglio ,grazie

Dovrei fare un programmino in C,C++ che legga e scriva dei dati su
file .
Questi dati devono essere memorizzati nella stessa gerarchia di come
si vedono nel tree control di Esplora Risorse (finestra di sinistra) .
Come potrei implementare l'algoritmo ?
grazie


Scusa, non vorrei sembrarti sgarbato (di solito
cerco di aiutare, vedi miei messaggi precedenti)
pero' la tua domanda
1) mi sembra che si riferisca a win e non al C (o C++) come linguaggio e
quindi la devi porre nel gruppo it.comp.programmare.win32 o in generale
in un gruppo che corrisponda alla tua architettura o al tuo compilatore.
2) Non ti offendere, ma se rileggi la tua frase:
 > Questi dati devono essere memorizzati nella stessa gerarchia di come
 > si vedono nel tree control di Esplora Risorse (finestra di sinistra) .
A parte l'italiano maltrattato, non mi e' assolutamente chiaro cosa vuoi
ottenere. Non capisco cosa vuol dire "salvare dati in una gerachia".
Vuoi dire salvare dati in una sottodirectory o vuoi che i tuoi
dati siano internamente strutturati gerarchicamente ad albero ???
ciao,
g.

dati siano internamente strutturati gerarchicamente ad albero ???
Esatto. 



Dovresti usare "stat", che non e' ANSI ma POSIX, e in baso al tipo di file
(directory,regular file) disegnare pezzi dell'albero.
Ciao,
Riccardo
p.s. guarda che Giovanni aveva messo le mani avanti proprio per non
 essere frainteso
-- 
-=Riccardo Galli=-
 _,e.
s~  ``
 ~@.   ideralis Programs
.   ol 
 `**~  
http://www.sideralis.net


Forse potresti memorizzare insieme ai dati anche il loro percorso
all'interno del tree?
EMG
--
EMAG Software Homepage:     
http://www.emagsoftware.it
The EMG's ZX-Spectrum Page: 
http://www.emagsoftware.it/spectrum
The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg

 Esatto. 
Allora sembra di capire che vuoi memorizzare dentro
UN file dei dati organizzati gerarchicamente ad albero.
Allora alla base di tutto ci sara' una struct o due che
rappresentano un nodo dell'albero.
Un nodo dell'albero tipicamente avra' delle informazioni
come
1) identificatore del nodo (un numero, una stringa....) implicito o
esplicito.
2) un puntatore al nodo padre (per poter risalire se necessario)
3) il contenuto del nodo (o un puntatore al contenuto) se questo
nodo e' una foglia dell'albero (qui ci vanno i tuoi dati).
4) se il nodo e' interno allora ci va un puntatore ad una linked list
     degli eventuali nodi figli.
5) se richiesto puoi mettere piu' puntatori. Per esempio puoi
mettere un link tra nodi "fratelli".
Per risparmiare memoria (ed utilizzare una sola struct) puoi considerare
di utilizzare delle union.
Poi considera che ogni "link" in piu' che metti puo' accelerare alcune
operazioni sull'albero (ricerca di uno specifico nodo) ma rallentarne
altre (inserzione, cancellazione) e sprecare spazio.
Questa e' grosso modo il tipo di struttura ad albero che potrai tenere
in memoria centrale. Naturalmente la struttura vera e propria e 
soprattutto la sua  implementatazione e memorizzazione in memoria
secondaria (cioe' come file su disco) dipende da tante cose che non ci
hai detto:
1) i dati che vuoi associare alle foglie degli alberi hanno dimensione
    fissa o variabile. E in ogni caso quanto sono grandi ?
2) che dimensioni hanno tipicamente gli alberi che vuoi memorizzare?
    Cioe': quale e' il numero tipico di "rami" che partono da un nodo,
     quale e' il numero tipico di foglie complessive.
3) La modifica della struttura dati gerarchica memorizzata all'interno
di un file deve poter avvenire anche "su disco" o solo quando il file
e' stato letto in memoria centrale ?
4) quali operazioni vanno implementate su questi alberi e quanto sono
time-critical ?
Insomma l'implementazione secondo me puo' cambiare in modo sostanziale
se stiamo parlando di una struttura gerarchica di al massimo 100 record
ognuno lungo 32 byte da aggiornare 5 volte in memoria centrale usando il
file su disco per salvare, o se vogliamo considerare una struttura dati
di un milione di nodi ciascuno lungo 1 Kb sul quale fare molte migliaia
di operazioni di inserzione/cancellazione lavorando sul disco e nel piu'
breve tempo possibile.
Se per esempio questa seconda fosse la situazione tipica allora
converrebbe tenere separati i dati dalla struttura: la struttura
potrebbe essere caricata sempre in memoria centrale mentre il file
dei dati potrebbe essere organizzato internamente come una specie di
disco virtuale, con tanto di tabella di allocazione, lista delle
posizioni eventualmente liberate da una cancellazione etc.etc.
ciao,
g.

Come potrei implementare l'algoritmo ?
Cosě, su due piedi, l'idea che mi viene in mente č quella di costruire
una "struct" per ogni nodo, che "punti" a un numero imprecisato di
"struct" figlie.  Il valore di questi puntatori (che puoi implementare
con un array di interi) č l'offset all'interno del file.
+- topolino
|  |- pluto
|
+- paperino
|  |- qui
|  |  |- baseball
|  |- quo
|  |- qua
...
offset
--------------------------------------------------
000001  [topolino][000002][000000][000000][000000]
000002  [pluto   ][000000][000000][000000][000000]
000003  [paperino][000004][000005][000006][000000]
000004  [qui     ][000007][000000][000000][000000]
000005  [quo     ][000000][000000][000000][000000]
000006  [qua     ][000000][000000][000000][000000]
000007  [baseball][000000][000000][000000][000000]
...
-- 
Andrea Laforgia
"640kb of memory should be enough for anyone." -- Bill Gates.

Ringrazio per i Vostri consigli .
Io avevo pensato a qualcosa del tipo :
#define MAX_OBJ 100
 class OBJ {
  public :
 OBJ *RecursivePtr ;  // punta all'oggetto di livello piu basso
 (OBJ  *vectorObj)[MAX_OBJ] ; // punta a oggetti dello stesso livello
 
 int  NumObj ; // contatore di oggetti dello stesso livello
 /* qui i dati ...... */
/* qui i metodi di interfacciamento*/
 } ;
Cioe' visto che gli oggetti sono tutti uguali con un puntatore
"ricorsivo" mi sposto ad un oggetto di livello inferiore e il vettore
di puntatori mi permette di dichiarare altri oggetti allo stesso
livello(che a loro volta avranno il puntatore ricorsivo ecct.....) .
Il dubbio che mi sorge e' se riusciro a tenere sincronizzato il tutto
o se rischio di perdermi fra qualche oggetto.
I dati presenti in ogni oggetto compileranno un item di un Tree
Control durante l'operazione di lettura dal file in modo da
ricostruire la gerarchia grafica completa .
Le modifiche avverranno (credo) solo all'interno del controllo e in
fase di chiusura l'intera struttura gerarchica dovra' essere verra
salvata di nuovo sul disco .

e gentile 
Se e' la gentilezza che muove le tue azioni allora apprezzo
notevolemente il tuo contributo che per'altro mi sembra molto valido e
costruttivo.
Grazie