desvio de bits para a esquerda (<<) e para a direita (>>)

Há dois operadores de desvio de bits em C++: o de desvio para a esquerda << e o para a direita >>. Estes operadores fazem com que os bits no operando da esquerda sejam desviados o número especificado de bits no operando da direita.

Sintaxe

variavel << numero_de_bits

variavel >> numero_de_bits

Parâmetros

variavel - (byte, int, long)

numero_de_bits inteiro <= 32

Exemplo:

    int a = 5;        // binario: 0000000000000101
    int b = a << 3;   // binario: 0000000000101000, ou 40 em decimal
    int c = b >> 3;   // binario: 0000000000000101, ou de volta ao 5 como no inicio

Quando você desvia para a esquerda um valor x um y número de bits (x<<Y) os bits mais a esquerda em x são perdidos:

    int a = 5;        // binario: 0000000000000101
    int b = a << 14;  // binario: 0100000000000000 - o primeiro 1 em 101 é descartado

Se você tem certeza de que nenhum dos 1 em um valor vai ser deviado para fora do espaço , um modo simples de pensar no operador para a esquerda é que ele multiplica o operando da direita por 2 elevado ao operador da esquerda. Por exemplo para gerar potências de 2 as segintes expressões podem ser utilizadas:

    1 <<  0  ==    1
    1 <<  1  ==    2
    1 <<  2  ==    4
    1 <<  3  ==    8
    ...
    1 <<  8  ==  256
    1 <<  9  ==  512
    1 << 10  == 1024
    ...

Quando você desvia para a direita um valor x um y número de bits (x>>y), o comportamento depende do tipo de dados de x. Se x é do tipo int, o bit mais elevado é o bit de sinal que determina se x é negativo ou não. Neste caso o bit do sinal é copiado para os bits inferiores por razões históricas esotéricas:

    int x = -16;     // binario: 1111111111110000
    int y = x >> 3;  // binario: 1111111111111110

Este comportamento é chamado extensão do sinal e freqüentemente não é o comportamento desejado. Entretanto, você pode desejar desviar preenchendo o espaço com zeros. Neste caso você deve utilizar uma alteração do tipo de dados que possui uma regra diferente para inteiros não assinalados:

    int x = -16;                   // binario: 1111111111110000
    int y = (unsigned int)x >> 3;  // binario: 0001111111111110

Se você for cauteloso em evitar a extensão do sinal, você pode usar o operador de desvio para a direita >> como um modo de dividir um número por potências de 2. Por exemplo:

    int x = 1000;
    int y = x >> 3;   // divisão inteira de 1000 por 8, resultado y=125.

Página de início da referência

Correções, sugestões, e nova documentação devem ser enviadas ao Forum.

O texto de referência do Arduino está baixo uma Licença Creative Commons Attribution-ShareAlike 3.0. Amostras de código utilizadas na referência foram deixados  ao domínio público.

O conteúdo desta página é uma tradução para o português a partir do site original do Arduino.