Newsgroup: it.comp.lang.c++
Titolo: Questione di ram, di bit (e spaccamento di *beep* )

Vi pongo un problema, devo creare in array in memoria che mi indichi se un
determinato byte in un file è già stato letto. La soluzione ideale sarebbe
creare un array di bool per tutta l'estensione del file. Dato che i tipi
bool usano solo 0 e 1 occupano lo stesso un'intero byte oppure un singolo
bit? Dato che non mi và di sprecare ram x nulla, come posso fare in modo di
utilizzare un singolo bit, magari definendo un nuovo tipo e chessoio....


ICQ #34602650

utilizzare un singolo bit, magari definendo un nuovo tipo e chessoio....
Puoi usare la classe bitset :
#include <bitset>
bitset<30> bitvec;
-- 
Roberto Gerola
Email: 
robert...@penguinpowered.com
WWW: 
http://www.penguinpowered.com/~The_Cpp_Compass

 utilizzare un singolo bit, magari definendo un nuovo tipo e chessoio....
se proprio vuoi fare un array, usa vector<bool> della librearia STL che
implementa
in modo particolare un array di bit ed e' trasparente all'uso.

 uno spazio di memoria minimo possibile, per quella soluzione.
Scusa, credevo di rispondere nel gruppo C.
Nella libreria standard esistono template di vettori che fanno al caso
tuo.





 bitset<30> bitvec;
Sigh! Sul mio DJGPP non funge... :-(
EMG


Se ti puo` consolare, tale classe non c'e` nemmeno
nel mio EGCS.
Mi sto rendendo conto che la libreria standard fornita
di serie tanto standard poi non e`.
Forse e` il caso di dare un'occhiata a STLPort come
suggeriva il buon Alex Martelli.


stato da f a t o viceversa.
In una opportuna organizzazione, la posizione del flag booleano indica direttamente
l'elemento corrispondente (come l'indice di un array). Sarebbe quindi informazione
ridondante e potenzialmente assai costosa da gestire e mantenere.
Paolo
-----------------------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
-----------------------------------------------------------------

 suggeriva il buon Alex Martelli.
Sai dirmi dove trovarla?
EMG

 ridondante e potenzialmente assai costosa da gestire e mantenere.
E' sicuramente vero che il formato proposto dall'amico potrebbe essere
dispendioso da gestire ma ridondante non mi pare. Anzi sembra una sorta
di compressione dei dati.
EMG

 di compressione dei dati.
Se utilizzi un array o comunque una struttura ordinata, la
posizione del byte modificato e` gia` espressa dalla posizione del
corrispondente flag all'interno della struttura. Questa posizione e`
comunque nota perche` ti serve per accedere al flag.
Certo non tutte le strutture esprimono esplicitamente la posizione come
l'indice di un array, ad esempio in una lista linkata non e` esplicita...
ma se alla lista accedi sequenzialmente, ad ogni passo di ricerca puoi
incrementare un contatore che alla fine ti fornisce la posizione.
La conosci sicuramente se hai modificato il byte e devi modificare il
relativo flag...
In questo contesto memorizzare insieme al flag anche la posizione del
byte corrispondente e` ridondante.
Invece una soluzione che farebbe risparmiare spazio potrebbe essere
l'uso di una struttura che associa al flag il numero di byte consecutivi
nella stessa situazione, ma non mi pare fosse questa la proposta (salvo
mia distrazione).
Saluti,
Paolo
-- 
------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
 
http://www.cli.di.unipi.it/~marotta
  G: Potreste commentare l'attuale
     panorama informatico?
  I: /* l'attuale panorama informatico */
------------------------------------------------


http://www.sltport.org


 stato da f a t o viceversa.
In effetti però non mi sembra sia implementabile.
EMG

In effetti però non mi sembra sia implementabile.
Direi che la cosa non e` cosi` semplice come possa sembrare...
Paolo
-----------------------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
-----------------------------------------------------------------


In effetti non è semplice specialmente che l'array è in continua modifica, e
ad ogni modifica bisognerebbe andare a gestire di nuovo l'array e
comprimerlo... un inutile utilizzo di cpu, per il mio prg l'array viene
letto e modificato circa 1000 volte al minuto... sarebbe da pazzi andare a
complicarsi la vita... la sfiga viene poi quando il file và oltre la misura
di ram allocabile e bisogna gestire il tutto via stream! mi fà impazzire
questa cosa.... gestendo i dati bit x bit si andrebbe a risparmiare un bel
po' di ram... mi stò documentando :)

comprimerlo... 
Non sarebbe necessario comprimere e decomprimere l'array in continuazione,
ma proprio questo sarebbe cio` che potrebbe creare qualche problema.



Posso proporre qualche cosa di diverso, che potrebbe ottenere lo stesso
risultato ?
Se si perche non ti tieni una lista di puntatori ad oggetti tipo :
struct blocco
{
 long da, a;
};
Dove nel 'da'c'e' la posizione nell'ambito del file il primo byte letto e
nel 'a' c'e' l'ultima per ogni blocco di bytes consecutivi.
Ovviamente ad ogni lettura devi modificare o aggiungere elementi alla lista.
La cosa puo' diventare efficiente se non hai molti frazionamenti come zone
lette ma piu' informazioni leggi
piu' si riduce lo spazio utilizzato in RAM.
Dimmi che ne pensi.
CIAO
ZEC

piu' si riduce lo spazio utilizzato in RAM.
In presenza di numerosi frammenti piccoli la soluzione puo` diventare dispendiosa
in termini di ram utilizzata (lo spazio utilizzato dall'implementazione della lista
diviene eccessivo rispetto alle informazioni contenute nel record, si potrebbe arrivare
poi ad utilizzare 2 long per contenere le informazioni memorizzabili in 2 bit)...



E' il rovescio della medaglia....
Curiosita' : Ti risulta che il lock sui file da parte di unix non venga
gestito in modo analogo ?
( Intendo con la lista, che mi sembra una cosa similare (non uguale) alla
richiesta fatta.)

gestito in modo analogo ?
Non saprei, non conosco unix!
