Poucowise Operadores em C: AND, OR, XOR, Shift e Complemento

O que são bitswise Operadores?

Poucowise Operadores são usados ​​para manipular dados em nível de bit, também chamado de programação em nível de bit. Pedaçowise opera em um ou mais padrões de bits ou números binários no nível de seus bits individuais. Eles são usados ​​em cálculos numéricos para tornar o processo de cálculo mais rápido.

Following é a lista de bitswise operadores fornecidos pela linguagem de programação 'C':

operador Significado
& Poucowise operador AND
| Poucowise operador OR
^ Poucowise operador OR exclusivo
~ O operador de complemento do binário é um operador unário
<< Operador de turno à esquerda
>> Operador de deslocamento para a direita

Poucowise operadores não podem ser aplicados diretamente a tipos de dados primitivos, como float, double, etc. Lembre-se sempre de uma coisa que um poucowise operadores são usados ​​principalmente com o tipo de dados inteiro devido à sua compatibilidade.

A partewise os operadores lógicos trabalham nos dados bit a bit, começando pelo bit menos significativo, ou seja, o bit LSB que é o bit mais à direita, trabalhando em direção ao MSB (Most Significant Bit) que é o bit mais à esquerda.

O resultado do cálculo do bitwise operadores lógicos são mostrados na tabela abaixo.

x y x e y x | lá x^y
0 0 0 0 0
0 1 0 1 1
1 0 0 1 1
1 1 1 1 0

Poucowise E

Este é um dos bits lógicos mais comumente usadoswise operadores. Ele é representado por um único sinal de E comercial (&). Duas expressões inteiras são escritas em cada lado do operador (&).
O resultado da mordidawise A operação AND é 1 se ambos os bits tiverem o valor 1; outrowise, o resultado é sempre 0.

Vamos considerar que temos 2 variáveis ​​op1 e op2 com valores como segue:

Op1 = 0000 1101
Op2 = 0001 1001

O resultado da operação AND nas variáveis ​​op1 e op2 será

Result = 0000 1001

Como podemos ver, duas variáveis ​​são comparadas pouco a pouco. Sempre que o valor de um bit em ambas as variáveis ​​for 1, o resultado será 1 ou então 0.

Poucowise OR

É representado por um único sinal de barra vertical (|). Duas expressões inteiras são escritas em cada lado do operador (|).

O resultado da mordidawise A operação OR é 1 se pelo menos uma das expressões tiver o valor 1; outrowise, o resultado é sempre 0.

Vamos considerar que temos 2 variáveis ​​op1 e op2 com valores como segue:

Op1 = 0000 1101
Op2 = 0001 1001

O resultado da operação OR nas variáveis ​​op1 e op2 será

Result = 0001 1101

Como podemos ver, duas variáveis ​​são comparadas pouco a pouco. Sempre que o valor de um bit em uma das variáveis ​​for 1, o resultado será 1 ou então 0.

Poucowise Exclusivo ou

É representado por um símbolo (^). Duas expressões inteiras são escritas em cada lado do operador (^).

O resultado da mordidawise A operação OR exclusiva é 1 se apenas uma das expressões tiver o valor 1; outrowise, o resultado é sempre 0.

Vamos considerar que temos 2 variáveis ​​op1 e op2 com valores como segue:

Op1 = 0000 1101
Op2 = 0001 1001

O resultado da operação XOR nas variáveis ​​op1 e op2 será

Result = 0001 0100

Como podemos ver, duas variáveis ​​são comparadas pouco a pouco. Sempre que apenas uma variável mantém o valor 1, o resultado é 0, caso contrário, 0 será o resultado.

Vamos escrever um programa simples que demonstre poucowise Operadores lógicos.

#include <stdio.h>
int main() 
{
int a = 20;	/* 20 = 010100 */  
int b = 21;	/* 21 = 010101 */
int c = 0;           

c = a & b;       /* 20 = 010100 */ 
printf("AND - Value of c is %d\n", c );

c = a | b;       /* 21 = 010101 */
printf("OR - Value of c is %d\n", c );

c = a ^ b;       /* 1 = 0001 */
printf("Exclusive-OR - Value of c is %d\n", c );

getch();
}

Saída:

AND - Value of c is 20
OR - Value of c is 21
Exclusive-OR - Value of c is 1

Poucowise operadores de turno

A partewise operadores de deslocamento são usados ​​para mover/deslocar os padrões de bits para o lado esquerdo ou direito. Esquerda e direita são dois operadores de turno fornecidos por 'C'que são representados da seguinte forma:

Operand << n (Left Shift)
Operand >> n (Right Shift)

Aqui,

  • um operando é uma expressão inteira na qual devemos realizar a operação de deslocamento.
  • 'n' é o número total de posições de bits que precisamos mudar na expressão inteira.

A operação de deslocamento para a esquerda deslocará o número 'n' de bits para o lado esquerdo. Os bits mais à esquerda na expressão serão exibidos e n bits com o valor 0 serão preenchidos no lado direito.

A operação de deslocamento para a direita deslocará o número 'n' de bits para o lado direito. Os 'n' bits mais à direita da expressão serão exibidos e o valor 0 será preenchido no lado esquerdo.

Exemplo: x é uma expressão inteira com dados 1111. Após realizar a operação shift o resultado será:

x << 2 (left shift) = 1111<<2 = 1100
x>>2 (right shift) = 1111>>2 = 0011

Os operadores de turnos podem ser combinados e usados ​​para extrair os dados da expressão inteira. Vamos escrever um programa para demonstrar o uso de bitswise operadores de turno.

#include <stdio.h>
int main() {
int a = 20;	/* 20 = 010100 */  
int c = 0;           

c = a << 2;	/* 80 = 101000 */
printf("Left shift - Value of c is %d\n", c );

c = a >> 2;	/*05 = 000101 */
printf("Right shift - Value of c is %d\n", c );
return 0;
}

Saída:

Left shift - Value of c is 80
Right shift - Value of c is 5

Após realizar a operação de deslocamento para a esquerda o valor se tornará 80 cujo equivalente binário é 101000.

Após realizar a operação de deslocamento para a direita, o valor passará a ser 5 cujo equivalente binário é 000101.

Poucowise operador complemento

A partewise complemento também é chamado de operador de complemento, pois sempre leva apenas um valor ou um operando. É um operador unário.

Quando realizamos complemento em qualquer bit, todos os 1 se tornam 0 e vice-versa.

Se tivermos uma expressão inteira que contém 0000 1111, depois de executar o bitwise operação complementar o valor passará a ser 1111 0000.

Poucowise O operador complemento é denotado pelo símbolo til (~).

Vamos escrever um programa que demonstre a implementação de bitwise operador complemento.

#include <stdio.h>
int main() {
int a = 10;	/* 10 = 1010 */  
int c = 0;           
c = ~(a);      
printf("Complement - Value of c is %d\n", c );
return 0;
}

Saída:

Complement - Value of c is -11

Aqui está outro programa, com um exemplo de todas as operações discutidas até agora:

#include <stdio.h>
main() {
unsigned int x = 48;	/* 48 = 0011 0000 */  
unsigned int y = 13;	/* 13 = 0000 1101 */
int z = 0;           

z =x & y;       /* 0 = 0000 0000 */ 
printf("Bitwise AND Operator - x & y = %d\n", z );

z = x | y;       /* 61 = 0011 1101 */
printf("Bitwise OR Operator - x | y = %d\n", z );

z= x^y;       /* 61 = 0011 1101 */
printf("Bitwise XOR Operator- x^y= %d\n", z);

z = ~x;          /*-49 = 11001111 */
printf("Bitwise One's Complement Operator - ~x = %d\n", z);

z = x << 2;     /* 192 = 1100 0000 */
printf("Bitwise Left Shift Operator x << 2= %d\n", z );

z= x >> 2;     /* 12 = 0000 1100 */
printf ("Bitwise Right Shift Operator x >> 2= %d\n", z );}

Depois de compilarmos e executarmos o programa, ele produz o seguintewing resultado:

Bitwise AND Operator - x & y = 0
Bitwise OR Operator - x | y = 61
Bitwise XOR Operator- x^y= 61
Bitwise One's Complement Operator - ~x = -49
Bitwise Left Shift Operator x << 2= 192
Bitwise Right Shift Operator x >> 2= 12

Resumo

  • Poucowise operadores são conjuntos de operadores especiais fornecidos por 'C.'
  • Eles são usados ​​na programação em nível de bit.
  • Esses operadores são usados ​​para manipular bits de uma expressão inteira.
  • Lógico, deslocamento e complemento são três tipos de bitswise operadores.
  • Poucowise O operador complemento é usado para reverter os bits de uma expressão.