Fare lo shift in una sola variabile...

di il
2 risposte

Fare lo shift in una sola variabile...

Raga oggi all'università il prof ha spiegato come fare lo shift ad una variabile e ci ha detto di creare un programma che converte da decimale a binario... il mio problema consiste nel fatto che il mio compilatore da un errore quando provo ad eseguire lo shift dando l'istruzione

numero<<1// in teoria dovrebbe fare lo shift a sinistra di 1
 

è un errore sintattico?? ho provato anche ad operare nel seguente modo
numero*2; ho provato a fare una  moltiplicazione per 2,il mio prof ha detto che in binario equivale a fare una moltiplicazione x 10 (anche se il secondo metodo non mi è chiaro...avrò sicuramente sbagliato a capire visto che il compilatore dovrebbe eseguire una semplice moltiplicazione per 2)
 
mi potete dare una mano a capire?grazie

2 Risposte

  • Re: Fare lo shift in una sola variabile...

    Dunque partiamo col dire che un numero binario lo converti in decimale moltiplicando l'elemento i-esimo ( partendo da destra e contando da 0 ) per 2^i.
    Quindi 01001 sarà 1 * 2^0 + 0 * 2^1 + 0 * 2^2 + 1 * 2^3 + 0 * 2^4 = 2^0 + 2^3 = 9

    Ne segue che "shift"-ando di un posto tutti gli elementi a destra è come eseguire l'operazione di divisione per 2^n ( con n numero dei posti traslati ) oppure se lo shift è verso sinistra è come moltiplicare per 2^n.

    Questa premessa per dire che per convertire un numero decimale in binario ci sono almeno due strade. La prima è quella di applicare la divisione per 2 e memorizzare il resto ( il procedimento che si fa di solito manualmente ). Però trattandosi di programmazione possiamo sfruttare il modo di ragionare del programma che vede già di per se una qualsiasi variabile come numero binario. Quindi rimane solo da visualizzare quella serie di 0 e 1, e lo si può fare aiutandosi con il codice ascii ( es. 0x30 = '0' e 0x31 = '1' )

    Da qui per convertire un "int" in una *stringa* binaria:
    
    char *bstr;
    int value = 123;
    int size, i;
    
    /* 8 in quanto lo spazio per memorizzare tutte le successione di 0 e 1 sono
    dipendenti da quanti byte sono riservati ad una variabile di tipo int sul computer
    su cui viene eseguito il programma, e moltiplicando per 8 questo valore abbiamo
    il numero di bit */
    size = sizeof (int) * 8;
    bstr = (char *) malloc (size);
    for ( i = 0; i < size; i++ ) {
          bstr[size - (i + 1)] = 0x30 + ((value >> size) & 1);
    }
    
    printf ("Valore %d: %s\n", value, bstr);
    free (bstr);
    


    Questo codice non fa altro che vedere il numero come (esempio):
    00000000 00000000 00000000 01111011
    ( Sul mio sistema l'int occupa 4 byte )

    E scorrendo tutti i bit applica una maschera ( & 1 ) all'ultimo bit ( trovato dopo lo shift ) in modo da avere solo il valore del bit corrente che si sta analizzando.
    Esempio dei primi due cicli:
    
    00000000 00000000 00000000 01111011 >> 1
    00000000 00000000 00000000 00111101 & 1
    00000000 00000000 00000000 00000001 + 0x30 = '1' ( 0x31 in ascii )
    
    00000000 00000000 00000000 01111011 >> 2
    00000000 00000000 00000000 00011110 & 1
    00000000 00000000 00000000 00000000 + 0x30 = '0' ( 0x30 in ascii )
    
    Spero di averti detto qualcosa di utile
  • Re: Fare lo shift in una sola variabile...

    Sei un grande grazie di cuore!
Devi accedere o registrarti per scrivere nel forum
2 risposte