[C] Mascheramento dei bit

[fbcyborg]

Salve a tutti,

non riesco a capire bene come si fa il mascheramento dei bit.
Ho un tipo di dato unsigned long e mi servono i 3 bit meno significativi. Come li tiro fuori?
Qualcosa mi dice che dovrei fare una maschera di bit del tipo int mask = 3; e poi fare qualcosa del tipo if (miavariabile & mask) allora...
Solo che io non so bene come fare per verificare esattamente quanto vale ogni singolo bit.

Oppure dovrei fare 3 maschere di bit? Ma come dichiararle? Valori esadecimali? Binari??

Grazie.

[DanieleC88]

Basta usare (numero & 7): usando 3 ottieni invece i 2 bit meno significativi.

Se interessa conoscere uno alla volta i bit meno significativi puoi usare anche lo scorrimento verso destra per isolare l'ultimo bit ad ogni passo:

for (int i = 0; i < NumeroDiBit; ++i, numero >>= 1)
{
  unsigned char bit = (numero & 1);

  printf("Estratto il bit: %u.\n", bit);
}

[fbcyborg]

Ti ringrazio moltissimo!!!
Dunque preferisco utilizzare il primo metodo.

Allora, supponiamo che mi venga fornito un "unsigned long numero" e voglia comunicare il valore di ciascuno dei 3 bit meno significativi.

A seconda del valore di ciascun bit devo fare una certa cosa....

esattamente come dovrei fare?
Siccome hai detto che potrei usare anche lo scorrimento a destra, mi sono un po' confuso. Volendo usare solo il primo metodo?

Grazie ancora.

[DanieleC88]

Prova a cercare con la calcolatrice i valori che ti interessano: vedrai che 1, 3 e 5 isoleranno uno alla volta i bit meno significativi.

primo = (numero & 1);
secondo = (numero & 3) >> 1;
terzo = (numero & 5) >> 2;

[fbcyborg]

Oddio, scusami ma continua la mia confusione. Ci metterò un po' per capire bene ma ci riusciro!!!

Allora.. prima hai detto 7=111 .. OK!
Io ho una variabile unsigned long my_var, e di questa variabile mi interessano i tre bit meno significativi. A seconda del valore di ciascuno di essi devo fare qualcosa (ad esempio incrementare un contatore).
Se il bit 0 è 1 devo fare una certa operazione
Se il bit 0 è 0 devo fare un'altra operazione
Se il bit 1 è 1 devo fare una certa operazione
Se il bit 1 è 0 devo fare un'altra operazione
Se il bit 2 è 1 devo fare una certa operazione
Se il bit 2 è 0 devo fare un'altra operazione

Mi sto confondendo per il fatto che mi hai detto di mettere 1, 3 e 5.

[DanieleC88]

In effetti dovevano essere 1, 2 e 4... sorry...
Ho risposto di fretta, scusa, comunque il ragionamento è più o meno lo stesso, dovresti essere in grado di fare da solo a questo punto.

[fbcyborg]

Allora..
per vedere quanto vale il primo bit meno significativo e memorizzarlo faccio:
int a = (my_var & 1);
per il secondo bit
int b = (my_var & 1) >> 1
per il terzo:
int c = (my_var & 1) >> 2

[DanieleC88]

Quasi:

int a = (n & 1) >> 0; /* qui lo shift è superfluo */
int b = (n & 2) >> 1;
int c = (n & 4) >> 2;

[fbcyborg]

Ok, ti ringrazio.. adesso invece vorrei capire bene cosa accade.
Provo con un esempio.
rappresentazione in bit
n = 111
n, è di 32 bit, ma rappresento solo i primi 3 meno significativi.
dunque, facendo
a = (n & 1) verifico il bit 0
facendo
b = (n & 2) >> 1
(quì mi perdo un po'... )
ora vedo quanto vale il secondo bit ma non capisco lo shift che dovrebbe portarmi ad una situazione del tipo n=011
e poi shiftando di 2???

Cacchio!

[DanieleC88]

No, tu vuoi conoscere solo e soltanto il valore del bit (che può assumere i soli valori 0 e 1), quindi tu hai:

n = 11101110111111 in base 2

Prendi il secondo bit usando un filtro come quello di prima:

mask = (1 << 1) = 2 = 10 in base 2

Otterrai:

bit = (n & mask) = 10 in base 2

Come noti, per riportare il valore a 0 o 1, devi operare uno shift:

n = (bit >> 1) = 1

ciao

[Furla]

Originariamente inviato da DanieleC88

Quasi:

int a = (n & 1) >> 0; /* qui lo shift è superfluo */
int b = (n & 2) >> 1;
int c = (n & 4) >> 2;

in tutti i casi lo shift è superfluo, perché il C riconosce come true qualsiasi valore diverso da 0 (non importa portarli in prima posizione, basta fare bene il test).

fbcyborg, per evitare di fare confusione hai due scelte: o ti impari il binario per bene e ti fai le maschere ad-hoc o segui questa semplicissima regola:

//isolo il bit con indice i (considerando 0 l'indice del LSB) di un intero k
int k=...;
int i=...;
bool bit=k & 1<<i;

[DanieleC88]

Originariamente inviato da Furla

in tutti i casi lo shift è superfluo

Non in tutti i casi: lo è solo quando lui ha bisogno strettamente di testarlo (se lui fa ValoreBit = (n & 5) su n = 7, otterrà 5 invece di 1, che è ciò che lui vuole).

[fbcyborg]

Originariamente inviato da DanieleC88

Non in tutti i casi: lo è solo quando lui ha bisogno strettamente di testarlo (se lui fa ValoreBit = (n & 5) su n = 7, otterrà 5 invece di 1, che è ciò che lui vuole).

No scusate.. io ho 32 bit, di cui mi interessano solo i 3 meno significativi. Io devo vedere il valore di ciascun bit, se è 0 o 1. A seconda di quanto vale, 0 o 1 (e non 5) devo fare una determinata cosa.

Potete consigliarmi qualcosa dove studiarlo??? Io faccio confusione anche perché quì si uniscono due concetti, l'and bit a bit e lo shift. Nonostante sappia cosa siano entrambi, quando li vado a combinare mi incasino.

[fbcyborg]

Allora!
Forse ho capito.
Il sistema dovrebbe essere analogo a quello della gestione dei permessi su Linux (777=111 111 111 111 = rwx ... )
Quello che mi fa confondere è il fatto che devo (ritornando al nostro discorso) vedere quanto valgono i primi tre bit meno significativi di 32 forniti come input.
Forse lo shift mi serve proprio per spostarmi sulla prima, seconda e terza cifra
però questo non lo capisco benissimo:

int a = (n & 1) >> 0; /* qui lo shift è superfluo */
int b = (n & 2) >> 1;
int c = (n & 4) >> 2;

Dunque... supponiamo che n sia 00000000000000000000000000000111 (32 bit).
I primi 29 bit non mi interessa che siano pari a 0, tanto non li considero.
l'AND fra n e 1 dovrebbe essere questo:
00000000000000000000000000000111 AND
00000000000000000000000000000001 =
-------------------------------------------
00000000000000000000000000000001 OK, il primo bit è pari a 1

secondo caso:
00000000000000000000000000000111 AND
00000000000000000000000000000010 =
-------------------------------------------
00000000000000000000000000000010 OK il secondo bit è pari a 1
Ma quì, shiftare a destra di 1 a che mi serve? Il risultato diventerebbe appunto:
00000000000000000000000000000001
Mi serve forse per restituire un 1 e memorizzarlo in b ? (suppongo di sì)

Terzo caso:
00000000000000000000000000000111 AND
00000000000000000000000000000100 =
-------------------------------------------
00000000000000000000000000000100 OK il terzo bit è pari a 1
Se ho capito bene, shifto di 2 posizioni per avere di nuovo
00000000000000000000000000000001 e memorizzarlo in c.

Spero di aver capito adesso!!!

[DanieleC88]

Sì, hai capito bene: lo shift serve solo, dopo aver isolato il bit che ti serve, a riportare il valore nell'intervallo [0; 1]. Se hai bisogno solo di testarlo, cioè di verificare che quel bit non sia zero, allora puoi anche non fare lo shift, come precisava Furla.

[fbcyborg]

Grazie mille!
Ora sì che è chiaro allora.
In effetti ho solo bisogno di testarlo, e a questo punto non credo che sia necessario fare lo shift. In realtà non mi è ancora chiarissimo il motivo per cui dovrei riportare il valore nell'intervallo [0;1].

[DanieleC88]

Può servirti se tu vuoi (ad esempio usando quella formula dentro una macro) conoscere soltanto il valore del bit, che per definizione, è o 1 o 0. Può essere utile in condizioni dove i branch sono da evitare (non è il tuo caso).

[fbcyborg]

forse mi serve.. a pensarci bene.
Perché a seconda di questi 3 bit devo distinguere 8 casi differenti. Quindi penso di metterci lo shift.

[DanieleC88]

Be', no allora non ti serve, perché io intendevo se vuoi ricavare il valore del bit espresso come 0 o 1, ma se devi solo testarlo (vedere se è attivo o meno e agire di conseguenza) non hai bisogno di riportarlo tra 0 e 1.

[Furla]

Originariamente inviato da DanieleC88

Non in tutti i casi: lo è solo quando lui ha bisogno strettamente di testarlo (se lui fa ValoreBit = (n & 5) su n = 7, otterrà 5 invece di 1, che è ciò che lui vuole).

ovviamente mi riferivo a tutti i casi che hai citato, e più in generale a tutti quelli in cui si vuole isolare un solo bit (quando cioè la maschera è una potenza di 2); che mi sembra sia proprio il caso di fbcyborg, al quale consiglio di evitare le maschere scritte in base 10 perché poco leggibili. per rendere chiaro il loro funzionamento o usi lo shift o le scrivi in esadecimale che permette una conversione immediata (adatto specialmente a quelle più complicate, quando ti serve più di un bit).

int k=...;
//le seguenti istruzioni fanno la stessa cosa:
bool bit=k & 1<<27;
bool bit=k & 134217728;
bool bit=k & 0x08000000;
//inutile dire quale sia la più chiara