Newsgroup: it.comp.lang.visual-basic
Titolo: scrivere bit in un file

salve a tutti
non so se l'oggetto è giusto ma il mio problema è il seguente
devo scrivere in un file una sequenza (mooolto lunga) di bit
ovvero di 1 e 0
se lo scrivo in modalità testo il file viene di dimensioni spaventosamente
grandi
più o meno 8 volte le dimensioni dei dati grezzi, dovuto al fatto che ogni
singolo bit che tratto viene scritto come byte giusto?
come devo fare per scrivere il valore del bit? scrivere il file in modalità
binaria?
domanda di riserva:  :-))
per velocizzare le operazioni di creazione e scrittura su file cosa posso
fare?
o trovato le api:
    CreateFile
    WriteFile
ma non mi danno la possibilità di specificare la modalità....se dovessi
appunto come dicevo sopra accedere in modalità binaria come faccio?
oppure qualcuno è a conoscenza di dll in assembly che possano velocizzare
questa operazione?
grazie a tutti!!!!
ciao!
Marco

 modalità binaria?
impacchetti i dati 8 a 8, e li scrivi come byte.
per scrivere i byte sul file, guarderei open for random
-- 
Salutoni
Sergio
per rispondere... togli il group dall'indirizzo

 modalità binaria?
Non ci sono funzionalita' preimpostate perche' il bit non e' contemplato
come unita' di informazione, che al minimo arriva al byte.
Di conseguenza ti conviene sviluppare una semplice procedura per convertire
in byte le tue sequenze di bit, a blocchi di 8.
Sono poche righe di codice, una somma di multipli di 2.
Se non sai come fare fai un fischio.
-- 
Starman

 questa operazione?
se riesci, anche in C il linguaggio ti permette di usare bit 
fields. BAsta dichiarare un membro dati in una struct seguito 
dai due punti e da un numero intero (1-32) che ne specifica le 
dimensioni in bit. Nel tuo caso 1.
Se il compilatore lo supporta, anche un array di biet fields.
tipo
// uso le quadre perché ho il mouse rotto e il
// tastierino numerico lockato da mousepad
Struct BitsOfByte [
     Bits [8] : 1;
];
// definisce una matrice di strutture
BitsOfByte FileArray [ArraySize];
// scrive (setta) il millesimo (N = 1000) bit
FileArray [N / 8] . Bits [N % 8] = 1;
// legge il quarantesimo (Q = 40) bit
BoolValue = FileArray [Q / 8] . Bits [Q % 8];
Volendo si può anche lavorare solo di operatori booleani ed una 
tabella precalcolata con maschere di bit note uso comune.
Il codice è più illeggibile, ma paradossalmente più rapido 
dell'uso dei più intuitivi bit fields stessi.
Ti manderei del codice di esempio se solo avessi tempo di 
cercarlo .... Ma mo' non posso
ciao
CCCP++Mario


 CCCP++Mario

Ciao, ho trovato un file nel progetto del "compressore Huffmann 
like", che penso potrebbe andarti bene per adattare il codice 
(sempreché vuoi fare la DLL CPP). Ti posto quindi qualcosa che 
esemplifichi quanto detto prima
IMHO dovresti anche prevedere delle funzioni di livello 
superiore, tipo  "BitsStringRead"  e  "BitsStringWrite", la cui 
implementazione è banale avendo gli "atomi" di accesso ai 
singoli bits di un array di byte (è il tipo che chiamo 
"ptruchar"), perché se stai ad eseguire delle chiamate di 
funzione alla DLL per ogni BIT da leggere e scrivere, il puro e 
semplice overhead di chiamata standard e passaggio di parametri 
ti erode completamente il vantaggio del codice CPP su quello 
Basic, e non escludo che possa persino rivelarsi più lenta la 
chiamata alla DLL.
ciao
CCCP++Mario
// -----------------------------------------------------------
// -----------------------------------------------------------
typedef unsigned char * ptruchar;
typedef unsigned char uchar;
typedef unsigned long * ptrulong;
typedef unsigned long ulong;
// -----------------------------------------------------------
// -----------------------------------------------------------
static uchar SingleBitONEMask [ 8 ] =  { 1, 2, 4, 8, 16, 32, 64, 
128 };
static uchar SingleBitZEROMask [ 8 ] = { (255-1), (255-2), 
(255-4), (255-8), (255-16), (255-32), (255-64), (255-128) };
// -----------------------------------------------------------
// -----------------------------------------------------------
// ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
inline void SingleBit_SET (ptruchar Data, ulong BitPosiz)
// "standalone" version, usa gli SHIFTS
// { Data [(BitPosiz / 8)] |= (1 << (BitPosiz % 8)); };
// new version, utilizza le maschere statiche di bit standard
{ Data [(BitPosiz / 8)] |= SingleBitONEMask [(BitPosiz % 8)]; };
// ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
inline void SingleBit_ERASE (ptruchar Data, ulong BitPosiz)
// "standalone" version, usa gli SHIFTS
// { Data [(BitPosiz / 8)] &= (~(1 << (BitPosiz % 8))); };
// new version, utilizza le maschere statiche di bit standard
{ Data [(BitPosiz / 8)] &= SingleBitZEROMask [(BitPosiz % 8)]; };
// ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
inline unsigned SingleBitRead (ptruchar Data, ulong BitPosiz) const
// new version, utilizza le maschere statiche di bit standard
{ return (Data [ (BitPosiz / 8) ] & SingleBitONEMask [(BitPosiz 
% 8)]) ? (1) : (0) ; };
// ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
inline void SingleBitWrite (ptruchar Data, ulong BitPosiz, 
unsigned Status)
{ if (Status == 0) SingleBit_ERASE (BitPosiz); else 
SingleBit_SET (BitPosiz) ; };
// ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo