Neste tutorial, aprenderemos sobre operadores bit a bit em C ++ com a ajuda de exemplos.
Em C ++, os operadores bit a bit executam operações em dados inteiros no nível de bit individual. Essas operações incluem teste, configuração ou deslocamento dos bits reais. Por exemplo,
a & b; a | b;
Aqui está uma lista de 6 operadores bit a bit incluídos no C ++.
| Operador | Descrição |
|---|---|
& | Operador AND bit a bit |
| | Operador OR bit a bit |
^ | Operador XOR bit a bit |
~ | Operador de complemento bit a bit |
<< | Operador de deslocamento bit a bit para a esquerda |
>> | Operador Bitwise Shift Right |
Esses operadores são necessários porque a Unidade Lógica-Aritmética (ALU) presente na CPU do computador realiza operações aritméticas no nível de bits.
Nota: Os operadores bit a bit só pode ser usado juntamente com chare inttipos de dados.
1. Operador C ++ Bitwise AND
O operador AND bit a bit& retorna 1 se e somente se ambos os operandos forem 1 . Caso contrário, retorna 0 .
A tabela a seguir demonstra o funcionamento do operador AND bit a bit . Deixe um e b ser dois operandos que só pode assumir valores binários, ou seja, 1 e 0 .
| uma | b | a e b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Observação: a tabela acima é conhecida como "Tabela da verdade" para o operador AND bit a bit .
Vamos dar uma olhada na operação AND bit a bit de dois inteiros 12 e 25:
12 = 00001100 (em binário) 25 = 00011001 (em binário) // Bitwise AND Operação de 12 e 25 00001100 & 00011001 _________ 00001000 = 8 (em decimal)
Exemplo 1: bit a bit AND
#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; )
Resultado
a = 12 b = 25 a & b = 8
No exemplo acima, declaramos duas variáveis a e b. Aqui, observe a linha,
cout << "a & b = " << (a & b) << endl;
Aqui, estamos executando um AND bit a bit entre as variáveis a e b.
2. Operador C ++ Bitwise OR
O operador OR bit a bit| retorna 1 se pelo menos um dos operandos for 1 . Caso contrário, retorna 0 .
A seguinte tabela verdade demonstra o funcionamento do operador OR bit a bit . Deixe um e b ser dois operandos que só pode assumir valores binários, ou seja 1 ou 0 .
| uma | b | a | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Vejamos a operação OR bit a bit de dois inteiros 12 e 25 :
12 = 00001100 (em binário) 25 = 00011001 (em binário) Bitwise OU Operação de 12 e 25 00001100 | 00011001 _________ 00011101 = 29 (em decimal)
Exemplo 2: bit a bit OR
#include int main() ( int a = 12, b = 25; cout << "a = " << a << endl; cout << "b = " << b << endl; cout << "a | b = " << (a | b) << endl; return 0; )
Resultado
a = 12 b = 25 a | b = 29
O bit a bit OR de a = 12e b = 25dá 29.
3. Operador C ++ Bitwise XOR
O operador XOR bit a bit^ retorna 1 se e somente se um dos operandos for 1 . No entanto, se ambos os operandos forem 0 ou se ambos forem 1 , o resultado será 0 .
A seguinte tabela verdade demonstra o funcionamento do operador XOR bit a bit . Deixe um e b ser dois operandos que só pode assumir valores binários, ou seja 1 ou 0 .
| uma | b | a b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Vejamos a operação XOR bit a bit de dois inteiros 12 e 25:
12 = 00001100 (em binário) 25 = 00011001 (em binário) Operação de XOR bit a bit de 12 e 25 00001100 00011001 _________ 00010101 = 21 (em decimal)
Exemplo 3: XOR bit a 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; )
Resultado
a = 12 b = 25 a b = 21
O XOR bit a bit de a = 12e b = 25dá 21.
4. Operador de complemento bit a bit C ++
O operador de complemento bit a bit é um operador unário (funciona em apenas um operando). É denotado por ~que muda os dígitos binários de 1 para 0 e 0 para 1 .
Complemento bit a bit
É importante notar que o complemento bit a bit de qualquer inteiro N é igual a - (N + 1) . Por exemplo,
Considere um número inteiro 35 . De acordo com a regra, o complemento bit a bit de 35 deve ser - (35 + 1) = -36 . Agora, vamos ver se obtemos a resposta correta ou não.
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 deslocamos qualquer número para a direita, os bits menos significativos são descartados, enquanto os bits mais significativos são substituídos por zeros.
um pouco deslocamento para a direita
Como podemos ver na imagem acima, temos um número de 4 bits . Quando realizamos um one-bit operação de deslocamento direito sobre ele, cada bit individual é deslocada para a direita por 1 bit.
Como resultado, o bit mais à direita é descartado, enquanto o bit mais à esquerda permanece vago. Esta vaga é substituída por um 0 .
6. Operador de deslocamento esquerdo C ++
O operador de deslocamento para a esquerda desloca todos os bits para a esquerda por um certo número de bits especificados . É denotado por <<.
um pouco para a esquerda
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
Como resultado, a operação de deslocamento para a esquerda bit a bit para 13 (e qualquer outro número) pode ser diferente dependendo do número de bits pelos quais são representados.
Porque na representação de 32 bits , há muito mais bits que podem ser deslocados para a esquerda em comparação com a representação de 4 bits .
