English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Manual de referência ++Neste tutorial, vamos aprender sobre os operadores bit a bit do C
Operadores bit a bit. ++no C
ne, os operadores bit a bit executam operações em dados inteiros de nível de bit individual. Essas operações incluem testes, configurações ou deslocamentos de bits reais. Por exemplo, a & b;
a | b; ++Este é o C6Contida em
Uma lista de operadores bit a bit. | Operador | Nome | Descrição |
---|---|---|---|
Exemplo | & | AND bit a bit | se um bit existe em ambos os operandos, o operador de AND bit a bit copia um bit para o resultado. 12será 1100 |
(A & B) será | ou | | | se um bit existe em qualquer um dos operandos, o operador de OR bit a bit copia um bit para o resultado. 61(A ^ B) será11 1101 |
(A | B) será | ^ | XOR bit a bit | se um bit existe em um dos operandos mas não em ambos, o operador de XOR bit a bit copia um bit para o resultado. 49(A ^ B) será11 0001 |
ou seja, 00 | complemento à esquerda | ~1O operador de complemento binário é um operador unário, que tem o efeito de "inverter" os bits, ou seja, 0 se torna1, | se torna 0. -61(~A) será 110ou seja110 00 |
<< | ,é a forma de complemento de um número binário de sinal. | Deslocamento à esquerda | Operador de deslocamento à esquerda em binário. O valor do operando à esquerda é movido para a esquerda pela quantidade especificada pelo operando à direita. 2 A >> 24A << 1111 0000 |
>> | 0,ou seja | Deslocamento à direita | Operador de deslocamento à direita em binário. O valor do operando à esquerda é movido para a direita pela quantidade especificada pelo operando à direita. 2 A >> 15será 1111 |
,ou seja, 0000
Esses operadores são necessários porque o processador de unidades aritméticas lógicas (ALU) do CPU do computador executa operações aritméticas a nível de bits.Atenção:
operador AND bit a bit(&)1apenas quando ambos os operandos forem1。Caso contrário, ele retornará 0.
A seguir, é demonstrado como o operador AND bit a bit funciona. Supondo que a e b sejam dois números binários que podem ser1e os operandos 0.
a | b | a & b |
---|---|---|
0 | 0 | 0 |
0 | 1 | 0 |
1 | 0 | 0 |
1 | 1 | 1 |
Atenção:A tabela é chamada de "tabela de valores verdade" para o operador AND bit a bit.
Vamos ver dois inteiros12e25Operação AND bit a bit:
12 = 00001100 (binário) 25 = 00011001 (binário) //12e25Operação AND bit a bit 00001100 & 00011001 _________ 00001000 = 8 (decimal)
#include <iostream> using namespace std; int main() { //Declarar variáveis int a = 12, b = 25; cout << "a = " << a << endl; cout << "b = " << b << endl; cout << "a & b = " << (a & b) << endl; return 0; }
Resultado de saída
a = 12 b = 25 a & b = 8
No exemplo acima, declaramos duas variáveis a e b. Aqui, note esta linha,
cout << "a & b = " << (a & b) << endl;
Aqui, executamos a operação de AND bit a bit entre as variáveis a e b.
O operador de OR ( | )1se pelo menos um dos operandos for1então o operador OR ( | ) retorna
A tabela verdade a seguir demonstra como o operador de OR bit a bit funciona. Supondoaebpara dois que podem ter apenas valores binários (ou seja1ou 0) dooperando.
a | b | Se pelo menos um dos operandos for |
---|---|---|
0 | 0 | 0 |
0 | 1 | 1 |
1 | 0 | 1 |
1 | 1 | 1 |
Vamos ver dois inteiros12e25a | b
12 = 00001100 (binário) 25 = 00011001 (binário) //12e25Operação de OR bit a bit: 00001100 operação de OR bit a bit11001 _________ 00011101 = 29 (decimal)
#include <iostream> int main() { int a = 12, b = 25; cout << "a = " << a << endl; cout << "b = " << b << endl; :operador de OR ( | ) return 0; }
Resultado de saída
a = 12 b = 25 cout << "a | b = " << (a | b) << endl; 29
a | b =ouonde a = 12e b = 25resulta em29.
apenas quando um dos operandos for1então o operador XOR ^ retorna1. Mas, se os dois operandos forem todos 0, ou todos1então o resultado é 0.
A tabela verdade a seguir demonstra como o operador de OR bit a bit funciona. Supondoaebpara dois que podem ter apenas valores binários (ou seja1ou 0) dooperando.
a | b | a ^ b |
---|---|---|
0 | 0 | 0 |
0 | 1 | 1 |
1 | 0 | 1 |
1 | 1 | 0 |
Vamos ver dois inteiros12e25Operação de XOR bit a bit:
12 = 00001100 (binário) 25 = 00011001 (binário) //12e25operação de XOR de bits 00001100 ^ 00011001 _________ 00010101 = 21 (decimal)
#include <iostream> int main() { int a = 12, b = 25; cout << "a = " << a << endl; cout << "b = " << b << endl; cout << "a ^ b = " << (a ^ b) << endl; return 0; }
Resultado de saída
a = 12 b = 25 a ^ b = 21
a = 12e b = 25A operação de XOR bit a bit resulta em21.
O operador de complemento à esquerda é um operador unário (ação em apenas um operando). Representado por ~, altera o número binário1Alterar 0 para1.
Notar que o complemento à esquerda de qualquer inteiro N é -(N+1)。Por exemplo
Por exemplo, inteiro35. Segundo as regras,35o complemento à esquerda bit a bit deve ser-(35 +1)= -36. Agora, vamos ver se obtemos a resposta correta.
35 = 00100011 (binário) // usando o operador de complemento à esquerda ~ 00100011 __________ 11011100
No exemplo acima, concluímos00100011(35)o complemento à esquerda bit a bit é11011100. Aqui, se convertirmos o resultado para decimal, obteremos220.
No entanto, é importante notar que não podemos converter diretamente o resultado para decimal para obter a saída necessária. Isso é porque o resultado binário11011100também é equivalente a-36.
Para entender isso, precisamos primeiro calcular-36saída binária.2usando o complemento à esquerda para calcular números binários negativos.
No cálculo binário,1O complemento à esquerda 0 alterado para1, teremos1E, se alterarmos 0 para1O resultado do complemento à esquerda adicionado1Se fazemos isso, obteremos o número original2complemento à esquerda.
Por exemplo,
36 = 00100100 (binário) 1complemento à esquerda = 11011011 2o complemento de bits : 11011011 + 1 _________ 11011100
Aqui, podemos ver36o2o complemento (ou-36) é11011100. Este valor é equivalente a35o complemento de bits.
Portanto, podemos dizer35O complemento de bits é-36.
#include <iostream> int main() { int num1 = 35; int num2 = -150; cout << "~(" << num1 << ") = " << (~num1) << endl; cout << "~(" << num2 << ") = " << (~num2) << endl; return 0; }
Resultado de saída
e35) = -36 e-150) = 149
No exemplo acima, declaramos duas variáveis inteiras num1e num2com valores35e-150 para inicializá-las.
Então usamos o código (~num1) e (~num2) calcular seus complementos de bits e exibi-los na tela.
35o complemento de 1 de ~ - (35 + 1) = -36 ou ~35 = -36 -15O complemento de 1 do zero = - (-150 + 1) = - (-149) = 149 ou ~(-150) = 149
Este é o valor que obtemos na saída.
C ++Existem dois operadores de deslocamento em programação:
Operador de deslocamento à direita >>
Operador de deslocamento à esquerda <<
O operador de deslocamento à direita move todos os bits à direita uma quantidade específica de bits. Representado por >>.
ao movermos qualquer número para a direita,Menor valor significativoserá descartado, enquantoMaior valor significativoserá substituído por zero.
Pode ser visto na figura acima que temos4número de bits. Quando executamos1bits.
O resultado, o bit mais à direita é descartado (Discarded), enquanto o mais à esquerda permanece vazio. Este espaço vazio é preenchido por0Substituição de bits (Replacement Bit).
O operador de deslocamento à esquerda move todos os bits à esquerda uma quantidade específica de bits. Representado por <<.
Pode ser visto na figura acima que temos4número de bits. Quando executamos1Operação de deslocamento à esquerda, cada bit individual se move1bits.
O resultado, o bit mais à esquerda é descartado (Discarded), enquanto o mais à direita permanece vazio. Este espaço vazio é preenchido por0Substituição de bits (Replacement Bit).
#include <iostream> int main() { //Declarar duas variáveis inteiras int num = 212, i; //Operação de deslocamento à direita cout << "Direita:\n" << endl; //Usar um loop for para mover o num de 0 bit para a direita3bit for (i = 0; i < 4; i++) { cout << "212 >> " << i << " = " << (212 >> i) << endl; } //Operação de deslocamento à esquerda cout << "\nEsquerda:\n" << endl; //Usar um loop for para mover o num de 0 bit para a esquerda3bit for (i = 0; i < 4; i++) { cout << "212 << " << i << " = " << (212 << i) << endl; } return 0; }
Resultado de saída
Deslocamento à direita: 212 >> 0 = 212 212 >> 1 = 106 212 >> 2 = 53 212 >> 3 = 26 Deslocamento à esquerda: 212 << 0 = 212 212 << 1 = 424 212 << 2 = 848 212 << 3 = 1696
A partir da saída do programa acima, podemos inferir que para qualquer númeroNPortanto, o resultado do operador de deslocamento à direita é:
N >> 0 = N N >> 1 = (N >> 0) / 2 N >> 2 = (N >> 1) / 2 N >> 3 = (N >> 2) / 2
etc.
Da mesma forma, o resultado do operador de deslocamento à esquerda é:
N << 0 = N N << 1 = (N << 0) * 2 N << 2 = (N << 1) * 2 N << 3 = (N << 2) * 2
etc.
Portanto, podemos concluir que,
N >> m = [ N >> (m-1) ] / 2 N << m = [ N << (m-1) ] * 2