In questo tutorial impareremo a conoscere gli operatori bit per bit in C ++ con l'aiuto di esempi.
In C ++, gli operatori bit per bit eseguono operazioni su dati interi a livello di singolo bit. Queste operazioni includono il test, l'impostazione o lo spostamento dei bit effettivi. Per esempio,
a & b; a | b;
Di seguito è riportato un elenco di 6 operatori bit per bit inclusi in C ++.
| Operatore | Descrizione |
|---|---|
& | Operatore AND bit per bit |
| | Operatore OR bit per bit |
^ | Operatore XOR bit per bit |
~ | Operatore di complemento bit per bit |
<< | Operatore di spostamento a sinistra di bit per bit |
>> | Operatore di spostamento a destra di bit per bit |
Questi operatori sono necessari perché l'ALU (Arithmetic-Logic Unit) presente nella CPU del computer esegue operazioni aritmetiche a livello di bit.
Nota: gli operatori bit per bit possono essere utilizzati solo insieme ai tipi di dati chare int.
1. Operatore AND bit per bit in C ++
L' operatore AND bit per bit & restituisce 1 se e solo se entrambi gli operandi sono 1 . In caso contrario, restituisce 0 .
La tabella seguente mostra il funzionamento dell'operatore AND bit per bit . Facciamo un e b tramite due operandi che possono assumere solo valori binari cioè 1 e 0 .
| un | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Nota: la tabella precedente è nota come "tabella della verità" per l' operatore AND bit per bit .
Diamo un'occhiata all'operazione AND bit per bit di due interi 12 e 25:
12 = 00001100 (in binario) 25 = 00011001 (in binario) // Operazione AND bit per bit di 12 e 25 00001100 e 00011001 _________ 00001000 = 8 (in decimale)
Esempio 1: AND bit per bit
#include using namespace std; int main() ( // declare variables int a = 12, b = 25; cout << "a = " << a << endl; cout << "b = " << b << endl; cout << "a & b = " << (a & b) << endl; return 0; )
Produzione
a = 12 b = 25 a & b = 8
Nell'esempio precedente, abbiamo dichiarato due variabili a e b. Qui, nota la linea,
cout << "a & b = " << (a & b) << endl;
Qui, stiamo eseguendo AND bit per bit tra le variabili a e b.
2. Operatore OR bit per bit C ++
L' operatore OR bit per bit | restituisce 1 se almeno uno degli operandi è 1 . In caso contrario, restituisce 0 .
La seguente tabella di verità mostra il funzionamento dell'operatore OR bit per bit . Facciamo un e b tramite due operandi che possono assumere solo valori binari esempio 1 o 0 .
| un | b | a | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Esaminiamo l' operazione OR bit per bit di due interi 12 e 25 :
12 = 00001100 (in binario) 25 = 00011001 (in binario) Operazione OR bit per bit di 12 e 25 00001100 | 00011001 _________ 00011101 = 29 (in decimale)
Esempio 2: OR bit per bit
#include int main() ( int a = 12, b = 25; cout << "a = " << a << endl; cout << "b = " << b << endl; cout << "a | b = " << (a | b) << endl; return 0; )
Produzione
a = 12 b = 25 a | b = 29
L' OR bit per bit di a = 12e b = 25dà 29.
3. Operatore XOR bit per bit C ++
L' operatore XOR bit per bit ^ restituisce 1 se e solo se uno degli operandi è 1 . Tuttavia, se entrambi gli operandi sono 0 o se entrambi sono 1 , il risultato è 0 .
La seguente tabella di verità mostra il funzionamento dell'operatore XOR bit per bit . Facciamo un e b tramite due operandi che possono assumere solo valori binari esempio 1 o 0 .
| un | b | a b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Esaminiamo l' operazione XOR bit per bit di due interi 12 e 25:
12 = 00001100 (in binario) 25 = 00011001 (in binario) Operazione XOR bit per bit di 12 e 25 00001100 00011001 _________ 00010101 = 21 (in decimale)
Esempio 3: XOR bit per bit
#include int main() ( int a = 12, b = 25; cout << "a = " << a << endl; cout << "b = " << b << endl; cout << "a b = " << (a b) << endl; return 0; )
Produzione
a = 12 b = 25 a b = 21
Lo XOR bit per bit di a = 12e b = 25dà 21.
4. Operatore di complemento bit per bit C ++
L'operatore di complemento bit per bit è un operatore unario (funziona su un solo operando). È indicato da ~che cambia le cifre binarie da 1 a 0 e da 0 a 1 .
Bitwise Complement
È importante notare che il complemento bit per bit di qualsiasi numero intero N è uguale a - (N + 1) . Per esempio,
Considera un numero intero 35 . Come da regola, il complemento bit per bit di 35 dovrebbe essere - (35 + 1) = -36 . Ora vediamo se otteniamo la risposta corretta o meno.
35 = 00100011 (In Binary) // Using bitwise complement operator ~ 00100011 __________ 11011100
In the above example, we get that the bitwise complement of 00100011 (35) is 11011100. Here, if we convert the result into decimal we get 220.
However, it is important to note that we cannot directly convert the result into decimal and get the desired output. This is because the binary result 11011100 is also equivalent to -36.
To understand this we first need to calculate the binary output of -36. We use 2's complement to calculate the binary of negative integers.
2's Complement
The 2's complement of a number N gives -N.
In binary arithmetic, 1's complement changes 0 to 1 and 1 to 0.
And, if we add 1 to the result of the 1's complement, we get the 2's complement of the original number.
For example,
36 = 00100100 (In Binary) 1's Complement = 11011011 2's Complement : 11011011 + 1 _________ 11011100
Here, we can see the 2's complement of 36 (i.e. -36) is 11011100. This value is equivalent to the bitwise complement of 35 that we have calculated in the previous section.
Hence, we can say that the bitwise complement of 35 = -36.
Example 4: Bitwise Complement
#include int main() ( int num1 = 35; int num2 = -150; cout << "~(" << num1 << ") = " << (~num1) << endl; cout << "~(" << num2 << ") = " << (~num2) << endl; return 0; )
Output
~(35) = -36 ~(-150) = 149
In the above example, we declared two integer variables num1 and num2, and initialized them with the values of 35 and -150 respectively.
We then computed their bitwise complement with the codes (~num1) and (~num2) respectively and displayed them on the screen.
The bitwise complement of 35 = - (35 + 1) = -36 i.e. ~35 = -36 The bitwise complement of -150 = - (-150 + 1) = - (-149) = 149 i.e. ~(-150) = 149
This is exactly what we got in the output.
C++ Shift Operators
There are two shift operators in C++ programming:
- Right shift operator
>> - Left shift operator
<<
5. C++ Right Shift Operator
The right shift operator shifts all bits towards the right by a certain number of specified bits. It is denoted by >>.
Quando spostiamo un numero qualsiasi a destra, i bit meno significativi vengono scartati, mentre i bit più significativi vengono sostituiti da zeri.
un po 'Shift destro
Come possiamo vedere dall'immagine sopra, abbiamo un numero a 4 bit . Quando eseguiamo un'operazione di spostamento a destra di un bit su di esso, ogni singolo bit viene spostato a destra di 1 bit.
Di conseguenza, il bit più a destra viene scartato, mentre il bit più a sinistra rimane vuoto. Questo posto vacante è sostituito da uno 0 .
6. Operatore C ++ Left Shift
L' operatore di spostamento a sinistra sposta tutti i bit verso sinistra di un certo numero di bit specificato . È indicato da <<.
un po 'Shift sinistro
As we can see from the image above, we have a 4-bit number. When we perform a 1 bit left shift operation on it, each individual bit is shifted to the left by 1 bit.
As a result, the left-most bit is discarded, while the right-most bit remains vacant. This vacancy is replaced by a 0.
Example 5: Shift Operators
#include int main() ( // declaring two integer variables int num = 212, i; // Shift Right Operation cout << "Shift Right:" << endl; // Using for loop for shifting num right from 0 bit to 3 bits for (i = 0; i < 4; i++) ( cout <> " << i << " = " <> i) << endl; ) // Shift Left Operation cout << "Shift Left:" << endl; // Using for loop for shifting num left from 0 bit to 3 bits for (i = 0; i < 4; i++) ( cout << "212 << " << i << " = " << (212 << i) << endl; ) return 0; )
Output
Shift Right: 212>> 0 = 212 212>> 1 = 106 212>> 2 = 53 212>> 3 = 26 Shift Left: 212 << 0 = 212 212 << 1 = 424 212 << 2 = 848 212 << 3 = 1696
From the output of the program above, we can infer that, for any number N, the results of the shift right operator are:
N>> 0 = N N>> 1 = (N>> 0) / 2 N>> 2 = (N>> 1) / 2 N>> 3 = (N>> 2) / 2
and so on.
Similarly, the results of the shift left operator are:
N << 0 = N N << 1 = (N << 0) * 2 N << 2 = (N << 1) * 2 N << 3 = (N << 2) * 2
and so on.
Hence we can conclude that,
N>> m = ( N>> (m-1) ) / 2 N << m = ( N << (m-1) ) * 2
In the above example, note that the int data type stores numbers in 32-bits i.e. an int value is represented by 32 binary digits.
However, our explanation for the bitwise shift operators used numbers represented in 4-bits.
For example, the base-10 number 13 can be represented in 4-bit and 32-bit as:
4-bit Representation of 13 = 1101 32-bit Representation of 13 = 00000000 00000000 00000000 00001101
Di conseguenza, l' operazione di spostamento a sinistra bit per bit per 13 (e qualsiasi altro numero) può essere diversa a seconda del numero di bit da cui sono rappresentati.
Perché nella rappresentazione a 32 bit , ci sono molti più bit che possono essere spostati a sinistra rispetto alla rappresentazione a 4 bit .
