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:
| Operador | Significado |
|---|---|
| & | 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 x | Operando y | x & y | x | y | x ^ y |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 0 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
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.
operando << n– desloca à esquerda, inserindo zeros à direita.operando >> n– desloca à direita, inserindo zeros à esquerda.
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
- Operadores bitwise são exclusivos para tipos inteiros e operam no nível binário.
- Incluem operações lógicas (AND, OR, XOR), shift (esquerda/direita) e complemento (~).
- Esses operadores são indispensáveis para tarefas como manipulação de flags, I/O de baixo nível e código crítico de desempenho.
Linguagem C
- Classes e Objetos em C#: Fundamentos para POO Robusta
- Dominando Classes e Métodos Abstratos em C#: Guia Prático
- Entendendo Classes e Métodos Parciais em C#
- Dominando Classes e Métodos Sealed em C#: Quando Usar, Exemplos Claros e Segurança de Código
- Dominando Operadores em C++: Guia Completo com Exemplos Práticos
- Palavras-chave e Identificadores em C: Um Guia Prático
- Dominando Operadores em Programação C: Um Guia Abrangente
- IoT e Blockchain: Uma Mudança de Paradigma na Confiança e Eficiência de Dados
- Operadores em C++ Explicados: Tipos, Exemplos e Programas Práticos
- Guia Abrangente de Operadores Python: Aritméticos, Lógicos, Comparação, Atribuição, Bitwise e Precedência