Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Industrial programming >> Linguagem C

Dominando Operadores Bitwise em C: AND, OR, XOR, Shifts e Complemento

O que são Operadores Bitwise?

Operadores bitwise manipulam bits individuais de valores inteiros. Diferente de operadores aritméticos que trabalham com números inteiros, operadores bitwise atuam na representação binária, tornando-os ideais para tarefas críticas de desempenho como flags, máscaras de bits e controle de dispositivos de baixo nível.

Em C, os seguintes operadores bitwise estão disponíveis:

OperadorSignificado
&AND Bitwise
|OR Bitwise
^XOR Bitwise (OU Exclusivo)
~NOT Bitwise (complemento de um)
<<Shift à esquerda
>>Shift à direita

Operadores bitwise são definidos apenas para tipos integrais; não são aplicáveis a tipos de ponto flutuante como float ou double.

As operações começam no bit menos significativo (LSB) e prosseguem em direção ao bit mais significativo (MSB). A tabela verdade a seguir resume os resultados binários:

Operando xOperando yx & yx | yx ^ y
00000
01011
10011
11110

Nas seções a seguir, mergulharemos mais fundo em cada operador com exemplos.

AND Bitwise (&)

O operador AND retorna 1 apenas quando ambos os bits correspondentes são 1; caso contrário, o resultado é 0. É comumente usado para mascarar bits indesejados.

 Op1 = 0000 1101
 Op2 = 0001 1001
 Result = 0000 1001 

OR Bitwise (|)

O operador OR retorna 1 se pelo menos um dos bits for 1. É útil para definir bits específicos.

 Op1 = 0000 1101
 Op2 = 0001 1001
 Result = 0001 1101 

XOR Bitwise (^)

O operador XOR retorna 1 apenas quando os bits diferem. É útil para alternar bits.

 Op1 = 0000 1101
 Op2 = 0001 1001
 Result = 0001 0100 

Programa de exemplo:

#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 - c = %d\n", c);
    c = a | b; /* 21 = 010101 */
    printf("OR - c = %d\n", c);
    c = a ^ b; /* 1 = 000001 */
    printf("XOR - c = %d\n", c);
    return 0;
}

Saída:

 AND - c = 20
 OR - c = 21
 XOR - c = 1 

Operadores de Shift Bitwise (<< e >>)

Operadores de shift movem bits para esquerda ou direita por uma contagem especificada.

Exemplo com número de 4 bits 1111:

 x << 2 → 1100
 x >> 2 → 0011 

Ilustração do programa:

#include <stdio.h>
int main() {
    int a = 20; /* 20 = 010100 */
    int c = 0;
    c = a << 2; /* 80 = 101000 */
    printf("Shift esquerda - c = %d\n", c);
    c = a >> 2; /* 5 = 000101 */
    printf("Shift direita - c = %d\n", c);
    return 0;
}

Saída:

 Shift esquerda - c = 80
 Shift direita - c = 5 

Complemento Bitwise (~)

O operador de complemento inverte todos os bits: 1 vira 0 e vice-versa. É um operador unário aplicado a um único operando.

 0000 1111 → 1111 0000 

Programa de exemplo:

#include <stdio.h>
int main() {
    int a = 10; /* 10 = 001010 */
    int c = ~a; /* -11 em complemento de dois */
    printf("Complemento - c = %d\n", c);
    return 0;
}

Saída:

 Complemento - c = -11 

Todos os Operadores Juntos

Abaixo está um programa conciso que demonstra cada operador bitwise discutido.

#include <stdio.h>
int main() {
    unsigned int x = 48; /* 0011 0000 */
    unsigned int y = 13; /* 0000 1101 */
    int z = 0;
    z = x & y; /* 0 = 0000 0000 */
    printf("AND - x & y = %d\n", z);
    z = x | y; /* 61 = 0011 1101 */
    printf("OR - x | y = %d\n", z);
    z = x ^ y; /* 61 = 0011 1101 */
    printf("XOR - x ^ y = %d\n", z);
    z = ~x; /* -49 = 1111 0100 (complemento de dois) */
    printf("NOT - ~x = %d\n", z);
    z = x << 2; /* 192 = 1100 0000 */
    printf("Shift esquerda - x << 2 = %d\n", z);
    z = x >> 2; /* 12 = 0000 1100 */
    printf("Shift direita - x >> 2 = %d\n", z);
    return 0;
}

Resultado:

 AND - x & y = 0
 OR - x | y = 61
 XOR - x ^ y = 61
 NOT - ~x = -49
 Shift esquerda - x << 2 = 192
 Shift direita - x >> 2 = 12 

Principais Pontos

Linguagem C

  1. Classes e Objetos em C#: Fundamentos para POO Robusta
  2. Dominando Classes e Métodos Abstratos em C#: Guia Prático
  3. Entendendo Classes e Métodos Parciais em C#
  4. Dominando Classes e Métodos Sealed em C#: Quando Usar, Exemplos Claros e Segurança de Código
  5. Dominando Operadores em C++: Guia Completo com Exemplos Práticos
  6. Palavras-chave e Identificadores em C: Um Guia Prático
  7. Dominando Operadores em Programação C: Um Guia Abrangente
  8. IoT e Blockchain: Uma Mudança de Paradigma na Confiança e Eficiência de Dados
  9. Operadores em C++ Explicados: Tipos, Exemplos e Programas Práticos
  10. Guia Abrangente de Operadores Python: Aritméticos, Lógicos, Comparação, Atribuição, Bitwise e Precedência