Operadores bitwew

Nisso Linux Dica Artigo, tudo sobre operações lógicas bit -bowise é explicado. Usando um exemplo prático com fragmentos de código de imagem, veremos em detalhes cada um dos operadores lógicos usados ​​no idioma C.

Além disso, explicaremos como executar o mascaramento de bits com operações lógicas, pois isso é algo muito útil na programação e está completamente relacionado a esse tipo de operador.

Descrição das operações bitwise

As operações bit -netwise são lógicas e as operações de mudança são aplicadas individualmente a cada bit de uma variável. Por exemplo, se aplicarmos a operação e entre as variáveis ​​"A" e "B", o bit 0 de "A" estará vinculado ao bit 0 de "B", o bit 1 de "A" será vinculado ao bit 1 de "B" ", e assim por diante.

Cada bit opera e retorna seu próprio resultado e não tem influência no resultado dos bits adjacentes a ele.

Esse tipo de operação é muito útil para mascarar bits ao usar sinalizadores ou indicadores de controle agrupados em um único item de dados, como um número inteiro.

Como atribuir um valor binário a uma variável no idioma C

Antes de começarmos a explicar o que são as operações lógicas bitwise, vejamos como atribuir um valor a uma variável no código binário, porque, embora possamos fazer isso em decimal, hexadecimal ou alguma outra representação, a visualização de 1s e 0 Muito mais prático e compreensível. Por exemplo, nos casos em que os bits representam sinalizadores ou indicadores de controle agrupados em uma variável int, dupla ou outra.

Para atribuir um valor a uma variável no formato binário, precisamos prefixar a representação binária com "0b". O snippet a seguir atribui o valor 131 ou 0B10000011 ao número inteiro "A" em formato binário e depois exibe sua representação decimal no console de comando.

#incluir
void main ()
int a;
a = 0b10000011;
printf ("A representação decimal para 0B10000011 é: %i \ n", a);

A imagem abaixo mostra o resultado para este código.

Representar valores binários nas operações bit -net e mascarador torna a programação muito mais fluida e compreensível e evita erros ou conversões que custam tempo.

Não operador

O operador lógico para o não é o símbolo “~”.

A operação lógica não ou de negação é a mais simples de todos, com apenas uma entrada e uma saída.

Esta operação retorna em sua saída o valor binário invertido de sua entrada.

Considere a seguinte expressão para a operação lógica não com a entrada "a"

C = ~ A

O resultado em "C" é igual a 1 se "A" for igual a 0 e "C" é igual a 0 se "a" for igual a 1. Esta operação é comumente usada para obter o valor complementar de uma variável.

Em seguida, vejamos a tabela de verdade para a operação não.

a	~	=	c
0	~	=	1
1	~	=	0

Exemplo:

Neste exemplo, aplicaremos a operação não à variável A para obter seu complemento em "C"

Para fazer isso, criamos a variável a do tipo de char não assinado, atribuímos o valor 131 e obtemos o resultado em "C". Em seguida, usamos a função printf () para exibir o resultado no console de comando. Abaixo, podemos ver o código para esse fim.

#incluir
void main ()

char não assinado c;
char não assinado a;
a = 0b01111100;
c = ~ a;
printf (“\ nA representação decimal para 0B10000011 é: %i \ n”, c);

Na figura abaixo, vemos o resultado do complemento de "A" . Nesse caso, o complemento ou inverso de 131 é 124 ou 01111100 em representação binária.

Lógico e operador

O operador lógico para a operação e é o símbolo "&"

Vejamos a seguinte expressão para a lógica e operação entre as variáveis ​​A e B

C = A & B.

O resultado em "C" é igual a 1 somente se "a" e "b" forem iguais a 1. Em todos os outros casos, "C" é igual a 0.

Em seguida, olhamos para a tabela de verdade para a operação e.

A	&	b	=	c
0	&	0	=	0
0	&	1	=	0
1	&	0	=	0
1	&	1	=	1

A operação lógica e é muito útil no mascaramento de bits. Mais tarde, veremos uma seção explicando esta técnica com mais detalhes.

Exemplo:

Agora, vamos ver um exemplo em que executamos o lógico e a operação entre as variáveis ​​"A" e "B" do tipo Char não assinado e armazenamos o resultado em "C" para exibi -lo mais tarde no console de comando.

Atribuímos o valor 135 ou 10000111 à variável "A" e 129 ou 1000001 à variável "B" na representação binária. Em seguida, usaremos o operador “&” 'para executar a operação. Em seguida, veremos o código para isso.

#incluir
void main ()

char não assinado a = 0b10000111;
char não assinado B = 0B10000001;
char não assinado c;
c = a & b;
printf ("\ n O resultado de A&B é: %i \ n", c);

A imagem mostra o resultado deste código em que a operação e a operação entre "a" e "b" resulta em 129 ou 10000001 em binário.

Lógico ou operador

O operador lógico para a operação OR é o símbolo ”| ““.

Vejamos a seguinte expressão para a lógica ou operação entre as variáveis ​​A e B

c = para | b.

O resultado em "C" será igual a 1 somente se "a" ou "b" ou "a" e "b" igual 1, enquanto será igual a 0 apenas se "a" e "b" ambos forem iguais 0.

Em seguida, vejamos a tabela de verdade para a operação ou.

para	|	b	=	c
0	|	0	=	0
0	|	1	=	1
1	|	0	=	1
1	|	1	=	1

Exemplo

Neste exemplo, veremos como executar a operação lógica ou entre as variáveis ​​”A” e “B” do tipo Char não assinado e armazenar o resultado em “C” para exibi -lo posteriormente no console de comando.

Atribuímos o valor 128 ou 10000000 à variável "A" e 3 ou 00000011 à variável "B" na representação binária. Em seguida, usaremos o operador “|” para executar a operação. Em seguida, veremos o código para esta operação.

#incluir
void main ()

char não assinado a = 0b10000000;
char não assinado B = 0B00000011;
char não assinado c;
c = para | b;
printf ("\ n O resultado de A | B é: %i \ n", c);

Na imagem abaixo, vemos o resultado da operação C = A | B que neste caso é 131 ou 10000011 em binário.

Operador lógico XOR ou exclusivo ou

O operador lógico da operação XOR é o símbolo ” ^“.

Vejamos a seguinte expressão para a operação lógica xor entre as variáveis ​​A e B

c = a ^ b.

O resultado em "C" é igual a 1 somente se um dos bits "a" ou "b" for igual a 1, mas é 0 se "a" e "b" forem iguais a 1 ou igual a 0.

Esta operação é essencial em Adders porque no sistema binário 1 + 0 = 1 ou 0 + 1 também é igual a 1. Mas 1 + 1 = 0 com transporte para o próximo bit mais alto. Nesse caso, o transporte é realizado pela operação e.

Em seguida, olhamos para a tabela de verdade para a operação XOR.

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

Exemplo

Agora, vejamos um exemplo em que executamos a operação lógica XOR entre as variáveis ​​"A" e "B" do tipo de char não assinado e armazenamos o resultado em "C" para exibi -lo posteriormente no console de comando.

Atribuímos o valor 135 ou 10000111 à variável "A" e 3 ou 00000011 à variável "B" na notação binária. Em seguida, usaremos o operador " ^" para executar a operação lógica. Em seguida, veremos o código para isso.

#incluir
void main ()

char não assinado a = 0b10000111;
char não assinado B = 0B00000011;
char não assinado c;
c = a ^ b;
printf ("\ n O resultado de A | B é: %i \ n", c);

Como podemos ver na imagem, o resultado é 10000100 e os bits cujas duas entradas são = 1 xor resulta em 0.

Operadores com atribuição

Os operadores com atribuição executam as mesmas operações lógicas que vimos antes, mas o resultado deles é armazenado no operando que precede o operador.

A expressão a seguir executa a lógica e a operação entre a variável "a" e a variável ou valor atribuído após o operador e o resultado é retornado em "a".

a & = 55;

Operadores de rotação

Os operadores de rotação são “< > ““.

Esses operadores alteram os dados de uma variável por bits "n" para a esquerda ou a direita, respectivamente.

Na expressão a seguir, o operador muda os dados armazenados em "a" 5 bits para a esquerda.

a = a < < 5

Exemplo

Neste exemplo, atribuiremos o valor 0B000001 à variável "A" e depois mudaremos 1 bit para a esquerda em um loop e produzirá o valor resultante no console de comando. Este ciclo é repetido 8 vezes

#incluir
void main ()

char não assinado a = 0b00000001;
char não assinado c;
para (int bit = 0; bit!= 8; bit ++)
printf ("%i \ n", a);
a = a<<1;

Na imagem a seguir, vemos o resultado com os valores decimais correspondentes a cada posição dos bits em um personagem não assinado.

Mascarar bit

Em certos casos, como quando definimos vários sinalizadores de controle agrupados em um único registro, precisamos apenas conhecer ou alterar o valor de um ou mais bits, não todo o registro.

Para obter o status de um ou mais bits específicos, precisamos definir uma máscara que defina apenas os bits dos elementos cujo valor queremos saber para 1 e aplicar o e operação.

Por exemplo, se queremos obter o valor dos bits 0 e 2 da variável "A", precisamos definir a seguinte máscara e executar a e operação.

00000101

Nesse caso, apenas o status dos bits 0 e 2 será retornado como resultado, os bits restantes terão o valor = 0, independentemente do valor que eles têm "a".

Para alterar o valor, temos que aplicar a operação ou entre a máscara com os bits que queremos definir como 1 e a variável que queremos mudar. Se quisermos defini -lo como 0, devemos inverter a máscara, como mostrado abaixo e aplicar o e operação.

11111010

Exemplo

Neste exemplo, usamos mascaramento de bits para criar um conversor simples e prático de números decimais para uma string com sua representação binária.

Para esta conversa, usaremos 8 máscaras, uma para cada bit, mas para tornar a programação mais prática e clara, primeiro usaremos a máscara 10000000 e depois moveremos um pouco para a direita em cada ciclo do loop. Dessa forma, teremos as 8 máscaras a seguir que precisamos.

10000000
01000000
00100000
00010000
00001000
00000100
00000010
00000001

O conversor consiste em um loop for 8 ciclos, em cada um dos quais, consulta o status do bit correspondente. Isso é feito por A e operação entre os dados a serem convertidos e a máscara correspondente.

Se o resultado da operação em "C" for 0, produza este valor com a função printf (). Caso contrário, se o valor do bit for 1, ele será impresso no console de comando.

Abaixo está o código para este conversor útil.

#incluir
void main ()
char não assinado a = 143;
char não assinado b = 0b10000000;
char não assinado c;
printf ("\ nA representação binária de A é:");
para (int bit = 0; bit!= 8; bit ++)
c = a & b;
if (c == 0)
printf ("0");
outro
printf ("1");
b = b >> 1;
c = 0;

printf ("\ n \ n");

Na imagem a seguir, vemos abaixo o resultado da conversão para o número 143.

Conclusão

Nisso Linux Dica Artigo, explicamos cada um dos operadores lógicos e de rotação que o idioma C fornece para o processamento bit a bit. Para cada um desses operadores, criamos uma seção mostrando o símbolo usado para essa descrição do operador e um exemplo prático com trechos de código e imagens para cada. Também incluímos uma seção que lida com mascaramento de bits e o que é uma adição, que está completamente relacionada a operações lógicas desse tipo.