Objetivos
        
    
    
    
        
Operadores Bit-a-bit/Bitwise
    
    
        
            
                Diferente dos operadores lógicos, os operadores bit-a-bit realizam operações sobre 
                os bit de uma variável ou expressão para setar(1) e resetar(0) seus bits.
            
            
                Abaixo serão listados os operadores suportados pela linguagem C:
            
         
     
    
        
            
                Tab. 1: Operadores bitwise
                
                    
                        | Operador | 
                        Significado | 
                        Exemplo | 
                    
                
                
                    
                        | & | 
                        E bit-a-bit | 
                        a & b | 
                    
                    
                        | | | 
                        Ou bit-a-bit | 
                        a | b | 
                    
                    
                        | ~ | 
                        Não bit-a-bit | 
                        ~a | 
                    
                    
                        | ^ | 
                        Ou Exclusivo bit-a-bit | 
                        a ^ b | 
                    
                    
                        | >> | 
                        Desloca N bits à direita | 
                        a>>b | 
                    
                    
                        | << | 
                        Desloca N bits à esquerda | 
                        a<<b | 
                    
                
            
         
     
    
    
        
            
                Levando em consideração a mesma ideia da tabela verdade do operador E lógico, 
                porém aplicadas aos bits entre duas variáveis ou expressões, podemos realizar a 
                operação E bit-a-bit como no exemplo abaixo:
            
            
                
                    
                         | 
                        Bit 7 | 
                        Bit 6 | 
                        Bit 5 | 
                        Bit 4 | 
                        Bit 3 | 
                        Bit 2 | 
                        Bit 1 | 
                        Bit 0 | 
                    
                
                
                    
                        | A | 
                        1 | 
                        0 | 
                        1 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                    
                    
                        | B | 
                        1 | 
                        0 | 
                        1 | 
                        0 | 
                        1 | 
                        1 | 
                        1 | 
                        1 | 
                    
                    
                        | A & B | 
                        1 | 
                        0 | 
                        1 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                    
                
            
            Sintaxe
            valor1/expressao1 & valor2/expressao2
            Exemplo 1
            
#include <stdio.h>
void main(void)  
{
    int varA = 0xa0,varB=0xaf;
    printf("%02x \n",varA & varB);
}
            Saída
            
a0
            
                O operador E bit-a-bit é utilizado para resetar bits de variáve, por exemplo. 
                Uma máscara é definida para representar os bits que desejamos manter ao aplicarmos 
                o operador.
            
            Exemplo 2
            
#include <stdio.h>
void main(void)  
{
    int varA = 0xaf,mascara=0x0f;
    printf("%02x \n",varA & mascara);
}
            Saída
            
0f 
         
     
    
    
        
            
                Levando em consideração a mesma idea da tabela verdade do operador OU lógico, 
                porém aplicadas aos bits entre duas variáveis, podemos realizar a operação 
                OU bit-a-bit como no exemplo abaixo:
            
            
                
                    
                         | 
                        Bit 7 | 
                        Bit 6 | 
                        Bit 5 | 
                        Bit 4 | 
                        Bit 3 | 
                        Bit 2 | 
                        Bit 1 | 
                        Bit 0 | 
                    
                
                
                    
                        | A | 
                        1 | 
                        0 | 
                        1 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                    
                    
                        | B | 
                        1 | 
                        0 | 
                        1 | 
                        0 | 
                        1 | 
                        1 | 
                        1 | 
                        1 | 
                    
                    
                        | A | B | 
                        1 | 
                        0 | 
                        1 | 
                        0 | 
                        1 | 
                        1 | 
                        1 | 
                        1 | 
                    
                
            
            Sintaxe
            valor1/expressao1 | valor2/expressao2
            Exemplo 3
            
#include <stdio.h>
void main(void)  
{
    int varA = 0xa0,varB=0xaf;
    printf("%x \n",varA | varB);
}
            Saída
            
af 
            
                O operador OU bit-a-bit é utilizado para setar bits de uma variável, por exemplo. 
                Uma máscara é definida para representar os bits que desejamos setar ao aplicarmos 
                o operador.
            
            Exemplo 4
            
#include <stdio.h>
void main(void)  
{
    int varA = 0xa0,mascara=0x0f;
    printf("%x \n",varA | mascara);
}
            Saída
            
af
         
     
    
    
        
            
                Levando em consideração a mesma idea da tabela verdade do operador Não lógico, 
                porém aplicadas aos bits entre duas variáveis, podemos realizar a operação 
                Não bit-a-bit como no exemplo abaixo:
            
            
                
                    
                         | 
                        Bit 7 | 
                        Bit 6 | 
                        Bit 5 | 
                        Bit 4 | 
                        Bit 3 | 
                        Bit 2 | 
                        Bit 1 | 
                        Bit 0 | 
                    
                
                
                    
                        | A | 
                        1 | 
                        0 | 
                        1 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                    
                    
                        | ~A | 
                        0 | 
                        1 | 
                        0 | 
                        1 | 
                        1 | 
                        1 | 
                        1 | 
                        1 | 
                    
                
            
            Sintaxe
            ~valor/expressao
            Exemplo 5
            
#include <stdio.h>
void main(void)  
{
    int varA = 0xf0;
    printf("%02x \n",~varA);
}
            Saída
            
0f
         
     
    
    
        
            
                O operador bit-a-bit Ou Exclusivo(^) possui sua tabela verdade que pode pode 
                ser resumida como: se os bits foram iguais, o resultado é 0, caso contrário, o resultado 
                é 1. 
            
            
                
                    
                         | 
                        Bit 7 | 
                        Bit 6 | 
                        Bit 5 | 
                        Bit 4 | 
                        Bit 3 | 
                        Bit 2 | 
                        Bit 1 | 
                        Bit 0 | 
                    
                
                
                    
                        | A | 
                        1 | 
                        0 | 
                        1 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                    
                    
                        | B | 
                        1 | 
                        0 | 
                        1 | 
                        0 | 
                        1 | 
                        1 | 
                        1 | 
                        1 | 
                    
                    
                        | A ^ B | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                        1 | 
                        1 | 
                        1 | 
                        1 | 
                    
                
            
            Sintaxe
            valor1/expressao1 ^ valor2/expressao2
            Exemplo 6
            #include <stdio.h>
void main(void)  
{
    int varA = 0xa0,varB=0xaf;
    printf("%02x \n",varA ^ varB);
}
            Saída
            
0f
         
     
    
    
        
            
                O operador bit-a-bit >>, de deslocamento à direita, desloca todos os bits 
                de uma variável ou expressão atribuindo 0 as bits mais significativos.
            
            
                
                    
                         | 
                        Bit 7 | 
                        Bit 6 | 
                        Bit 5 | 
                        Bit 4 | 
                        Bit 3 | 
                        Bit 2 | 
                        Bit 1 | 
                        Bit 0 | 
                        - | 
                    
                
                
                    
                        | A | 
                        1 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                        1 | 
                        - | 
                    
                    
                        | A>>1 | 
                        0 | 
                        1 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                        1 | 
                    
                
            
            Sintaxe
            valor/expressao >> qtd_bits_deslocar
            Exemplo 7
            #include <stdio.h>
void main(void)  
{
    int varA = 0x81;
    printf("%02x \n",varA >> 1);
}
            Saída
            
40
         
     
    
    
        
            
                O operador bit-a-bit <<, de deslocamento à esquerda, desloca todos os bits de uma variável ou expressão
                atribuindo 0 as bits menos significativos.
            
            
                
                    
                         | 
                        - | 
                        Bit 7 | 
                        Bit 6 | 
                        Bit 5 | 
                        Bit 4 | 
                        Bit 3 | 
                        Bit 2 | 
                        Bit 1 | 
                        Bit 0 | 
                    
                
                
                    
                        | A | 
                        - | 
                        1 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                        1 | 
                    
                    
                        | A<<1 | 
                        1 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                        0 | 
                        1 | 
                        0 | 
                    
                
            
            Sintaxe
            valor/expressao << qtd_bits_deslocar
            Exemplo 8
            #include <stdio.h>
void main(void)  
{
    int varA = 0x81;
    printf("%02x \n",varA <<1);
}
            Saída
            
02
         
     
    
        Histórico de atualizações
        
     
    
        
            
                - 03/09/2025 - revisão 5 - Ajustes: pontuais, css de tabs., sintaxes e objetivos
 
                - 10/03/2025 - revisão 3 - Remoção de link referência XOR errada; Adição de operadores de deslocamento >> e <<
 
                - 05/10/2024 - revisão 2 - Correção em Exemplos; Ajustes gramaticais pontuais
 
                - 27/09/2023 - revisão 1 - Correção em referências, erros gramaticais,layout, sintaxe e tabela E e OU
 
                - 19/05/2023 - versão inicial
 
            
         
     
    
            
            
                
                    
                    Os cursos oferecidos nesta página são cursos fornecidos por parceiros. Ao comprar um curso clicando
                em seu banner, você está ajudando a manter o projeto TutorialDev vivo. Os sites dos cursos parceiros utilizam cookies.