C/Variabili, operatori e costanti/Operatori sui bit

Il C è fornito di molti operatori sui bit. Queste operazioni possono essere eseguite solo sui tipi int e char, incluse le varianti ottenute con i modificatori long, short, signed e unsigned.

Ecco gli operatori:

• | OR;
• & AND;
• ^ XOR;
• << Scorri a sinistra;
• >> Scorri a destra;
• ~ Complemento a uno.

AND, OR e XOR

Gli operatori OR e AND hanno lo stesso funzionamento degli operatori logici, la differenza è che questi operano sui bit.

È stato aggiunto l'operatore XOR (OR esclusivo), che restituisce vero se solo un operando è vero. Funziona così:

a	b	c=a^b
0	0	0
0	1	1
1	0	1
1	1	0

Esempi

OR

int a=147;
int b=97;
int c=a|b; //OR
printf("c è uguale a %d", c);

Il risultato sarà: c è uguale a 243, perché:

128	64	32	16	8	4	2	1
1	0	0	1	0	0	1	1
0	1	1	0	0	0	0	1
1	1	1	1	0	0	1	1

AND

int a=147;
int b=97;
int c=a&b; //AND
printf("c è uguale a %d", c);

Il risultato sarà: c è uguale a 1, perché:

128	64	32	16	8	4	2	1
1	0	0	1	0	0	1	1
0	1	1	0	0	0	0	1
0	0	0	0	0	0	0	1

XOR

int a=147;
int b=97;
int c=a^b; //XOR
printf("c è uguale a %d", c);

Il risultato sarà: c è uguale a 242, perché:

128	64	32	16	8	4	2	1
1	0	0	1	0	0	1	1
0	1	1	0	0	0	0	1
1	1	1	1	0	0	1	0

Scorrimento a destra, a sinistra e complemento a uno

Gli operatori di scorrimento a destra e a sinistra fanno scorrere i bit della variabile specificata come primo operando verso destra o verso sinistra per il numero di volte specificato dal secondo operando. I bit fuoriusciti non rientreranno dall'altra estremità, ma andranno persi.

Il complemento a uno, invece, ha un funzionamento molto semplice. Esso inverte i bit, ovvero trasforma gli 1 in 0 e gli 0 in 1.

Esempi

Scorrimento a sinistra

int a=42;
int c=a<<1; //Scorrimento a sinistra
printf("c è uguale a %d", c);

Il risultato sarà: c è uguale a 84, perché:

128	64	32	16	8	4	2	1
0	0	1	0	1	0	1	0
0	1	0	1	0	1	0	0

Scorrimento a destra

int a=42;
int c=a>>1; //Scorrimento a destra
printf("c è uguale a %d", c);

Il risultato sarà: c è uguale a 21, perché:

128	64	32	16	8	4	2	1
0	0	1	0	1	0	1	0
0	0	0	1	0	1	0	1

Complemento a uno (o calcolo del valore negativo in base 2)

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
 unsigned char i=10;
 unsigned char j =~i;
 printf("%u", j);
}

Il risultato sarà 245, perché:

128	64	32	16	8	4	2	1
0	0	0	0	1	0	1	0
1	1	1	1	0	1	0	1