Memorizzare singoli bit in file??

di il
14 risposte

Memorizzare singoli bit in file??

Salve, ho un problema da che non riesco a risolvere da qualche giorno... tramite algoritmo di huffman, ho una sequenza di caratteri codificati da un certo numero di char (es... s->010110, a->110, t->0010 ecc) , che dovrei memorizzare su file... ma se li memorizzo normalmente però me li prende come caratteri quindi della grandezza di 8 bit ognuno, mentre io vorrei che venissero memorizzati su file come singoli bit quindi se devo scrivere "ta", sul file andrebbe scritto 1100010 ma come bit, non come valori! non so se mi sono spiegato... io voglio che il mio file in questo caso occupi 7 bit e non 7 byte! Grazie mille

14 Risposte

  • Re: Memorizzare singoli bit in file??

    Potresti compattarli tu in gruppi di 8 bit per scriverli come caratteri.

    Non vedo alternative.
  • Re: Memorizzare singoli bit in file??

    Grazie della risposta ma non ho capito cosa intendi... praticamente da un file di input con scritto x esempio "casa", tramite un algoritmo lo codifico... ottengo c->0010 a->11 s->101... quindi ottengo un codice 00101110111... se questo lo esporto in un file di output, prende 1 e 0 come char quindi casa che prima occupava 32 bit ora ne occupa 88... a me serve invece che il file prenda il mio codice come fosse 11 bit... cioè gli zeri e uni non sono char da 8 bit ma semplici bit!!!
  • Re: Memorizzare singoli bit in file??

    Potresti compattarli tu in gruppi di 8 bit per scriverli come caratteri.
    Ma se non sono dimensioni costanti come fa ad effetture l'operazione inversa?
  • Re: Memorizzare singoli bit in file??

    Non ha detto che li voleva rileggere ....

    P.S. Seguo la tua logica vbextreme ... dimenticavo vbextreme ... buon Natale ...
  • Re: Memorizzare singoli bit in file??

    marco8989 ha scritto:


    grazie della risposta ma non ho capito cosa intendi... praticamente da un file di input con scritto x esempio "casa", tramite un algoritmo lo codifico... ottengo c->0010 a->11 s->101... quindi ottengo un codice 00101110111... se questo lo esporto in un file di output, prende 1 e 0 come char quindi casa che prima occupava 32 bit ora ne occupa 88... a me serve invece che il file prenda il mio codice come fosse 11 bit... cioè gli zeri e uni non sono char da 8 bit ma semplici bit!!!
    Partiamo da una certezza di cui devi tenere sempre conto : devi memorizzare i dati a gruppi di 8 bit.

    Detto questo, potrai unire i tuoi bit (con gli opportuni operatori del linguaggio C) per formare byte da scrivere. Ad esempio per i tuoi 11 bit scriverai 2 byte (8 bit + 3 bit + 5 bit non utilizzati).

    Quando rileggerai, dovrai disporre del "dizionario" ovvero della corrispondenza bit/simboli.
  • Re: Memorizzare singoli bit in file??

    Ok perfetto, fin qui ci sono... ma come li memorizzo in un file?? partendo per esempio da una map<char,string > con chiavi le lettere e valori i codici di decodifica delle lettere... come ottengo il mio file binario??
  • Re: Memorizzare singoli bit in file??

    P.S. Seguo la tua logica vbextreme

    Ma non bastava una pecora nera????
    buon Natale
    Tardi,oggi è già il mio "buon non compleanno",quindi "buon non compleanno" a te oregon,e in culo alla balena per il prossimo anno
  • Re: Memorizzare singoli bit in file??

    Stavo dimentcando che huffman si basa su un albero,e quindi è inutile sapere la dimensione dei bit dato che si avrà la fine del dato quando si incorre in una foglia.....
    Ovvio nell'intestazione del file sarà necessario salvare l'albero.
    basta che scrivi anche una semplice 'a' per avere un file binario.

    Dato che l'unità di "misura" piu piccola che puoi salvare sono i byte,tu dovrai manipolare tale byte in base alle tue esigenze.
    Ad esempio mentre esegui la ricerca del carattere all'interno dell'albero puoi usare una variabile che ti memorizzi il percorso "var = 0;inizioricercacarattere(&var);var |= posizionePercorso; var << 1;" una volta raggiunto la posizione 8(se usi char) scrivi var sul file e torni ad azzerare var.

    So che non si è capito un tubo perciò "buon non compleanno" anche a te.
  • Re: Memorizzare singoli bit in file??

    Dove ottieni i valori in bit? Posta il codice con un minimo esempio ...

    @vbextreme ... basta che non aggiungi "babbe natale poco vestite" ...
  • Re: Memorizzare singoli bit in file??

    Oregon,questo forum é pieno di criptonite e tu non puoi usare i tuoi super poteri....

    Esatto posta il codice che stai usando magari riusciamo ad aiutarti meglio.
    Scusa oregon che ultimamente ha scoperto cosa il buon dio ci ha regalato.
  • Re: Memorizzare singoli bit in file??

    Allora, un pezzo di codice è questo, ma è fatto molto "semplice"...
    
    
    void codifica(){
         ifstream input;
         input.open("prova.txt",ios::in);
          ofstream output("output.txt",ios::binary);
         string stringa;
         getline(input,stringa);
     for(int i=0;i<stringa.length();i++){
                 for (map<char,string>::iterator it=encode.begin(); it!=encode.end(); ++it){
                     if(it->first==stringa[i]){
                                              output<<it->second; }
                                               }
                                               }
               
                                               }
         
    qui map contiene chiave->lettera, valore->"codifica binaria lettera (tipo 100101)...."ovviamente questo codice mette una stringa nel file, come dicevo... io volevo fare in modo che gli zeri e uni scritti nel file venissero presi come bit non come byte...
  • Re: Memorizzare singoli bit in file??

    Non è un compito banale.

    Dovrai trattare il contenuto della stringa individuata nel ciclo da it->second e trasformare i singoli caratteri in bit (da ASCII a binario, basta considerare solamente il primo bit a destra) e shiftarli in un byte temporaneo. Quando sarà riempito da 8 bit lo scriverai e passerai al prossimo (l'ultimo byte potrebbe non essere completo).

    Devi tenere conto che il byte in questione potrebbe essere riempito con più stringhe o parti di esse.

    Ad esempio, se hai una stringa "0100"

    i singoli caratteri '0' '1' '0' '0' saranno convertiti e inseriti nel byte così

    0100xxxx

    e se la prossima stringa conterrà "11" i singoli caratteri '1' '1' li aggiungerai nel byte

    010011xx

    e così via.

    La questione è inutilmente complicata.

    Potresti semplificare la questione memorizzando il dato nella map in un intero e non in una string.

    P.S. Cosa devi conoscere bene se ancora non li conosci : gli operatori binari logici and, or e quelli di shifting
  • Re: Memorizzare singoli bit in file??

    Uff... non è che mi è ben chiaro... cmq ho cercato su internet e ho trovato una """"soluzione""" che però non è chiarissima... qualcuno sa darmi un indizio di cosa fa??? e magari come implementarla... :S scusate ma sto compito mi porta via molto tempo e soprattutto pazienza!!!
    
    void writeBinary(char *huffmanEncoding, int sequenceLength)
    {
        char byte = 0;
        // For each bit of the sequence
        for (int i = 0; i  < sequenceLength; i++) {
            char bit = huffmanEncoding[i];
    
            // Add a single bit to byte
            if (bit == 1) {
                // MSB of the sequence to msb of the file
                byte |= (1 << (7 - (i % 8)));
                // equivalent form: byte |= (1 << (-(i + 1) % 8);
            }
            else {
                // MSB of the sequence to msb of the file
                byte &= ~(1 << (7 - (i % 8)));
                // equivalent form: byte &= ~(1 << (-(i + 1) % 8);
            }
    
            if ((i % 8) == 0 && i > 0) {
                //writeByteToFile(byte);
            }
        }
    
        // Fill the last incomplete byte, if any, and write to file
    }
    
  • Re: Memorizzare singoli bit in file??

    Dovrebbe essere proprio quello che ti serve; in pratica carica ad uno ad uno i bit dalla sequenza di interi a 8 bit huffmanEncoding (con soli valori 0 e 1) caricando il byte temporaneo e scaricando su file il byte quando si sono riempite le 8 posizioni (in realtà il salvataggio su file è commentato).
    Più semplicemente potresti fare (uso una printf() al posto della scrittura su file):
    void writeBinary(char *huffmanEncoding, int sequenceLength)
    {
        char byte;
       char mask;
    
        byte = 0;
        mask = 0x01;
        for (int i = 0; i  < sequenceLength; i++) {
            char bit = huffmanEncoding[i];    // legge bit corrente
    
            if (bit == 1) {         // se a 1 settiamo il relativo bit
                byte |= mask;
            }
    
            if( mask == 0x80 )   // se era l'ultimo bit del byte corrente, salviamolo
            {
               printf( "%02X ", byte );   // salvataggio
               byte = 0;                       // ripartenza prossimo byte
               mask = 0x01;
           }
           else                      // se non era l'ultimo bit del byte spostiamoci
               mask = mask << 1;
        }
    }
Devi accedere o registrarti per scrivere nel forum
14 risposte