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.

Esta obra está sob uma Licença Creative Commons.

Creative Commons License