Bitové operátory

Ako samotný názov napovedá, bitové operátory umožňujú vykonať operácie nad jednotlivými bitmi. Túto možnosť zďaleka nemajú všetky programovacie jazyky. Jazyk C ich má najmä preto, že bol vytvorený ako nástoj systémového programátora (OS Unix). Použitie bitových operátorov vyžaduje vedomosti o uložení bitov v pamäti, spôsobe kódovania čísel.

Bitové operátory sú: << >> & | ~ ^ , teda posun vľavo, posun vpravo, and, or, not a xor. Bitové operácie sú možné iba s celočíselnými hodnotami.

Bitové and &, or | a xor ^ vykonáva príslušnú binárnu operáciu s každým párom odpovedajúcich si bitov. Výsledok je umiestnený do pozície rovnakého binárneho rádu výsledku. Výsledky operácií nad jednotlivými bitmi sú rovnaké, ako v Booleovej algebre. Pozrime sa na jednotlivé zástupné znaky bitových operátorov.

<<  >> posun vľavo a vpravo

Pri bitovom posune vľavo (vpravo) <<  ( >> ) sa jednotlivé bity posúvajú vľavo (vpravo), teda do pozície s (binárne) vyšším (nižším) rádom. Na najpravejšiu (najľavejšiu) posunom vytvorenú pozíciu je umiestnená nula.

int a = 5;       // binárne: 0000000000000101
int b = a << 3;  // binárne: 0000000000101000, posun o 3 bity vľavo, pozície doplnené o nuly
int c = b >> 3;  // binárne: 0000000000000101, posun o 3 bity vpravo, pozície doplnené o nuly

Posuny však prebiehajú aritmeticky. To znamená, že uvedené pravidlo neplatí pre posun vpravo pre hodnoty celočíselného typu so znamienkom. V takomto prípade sa najvyšší bit (znamienkový) zachováva. Takto sa pri posune dopĺňa do bitového reťazca nový bit.

int x = -16;     // binárne: 1111111111110000, znamienkový bit (1 = záporné číslo; 0 = kladné číslo) 
int y = x >> 3;  // binárne: 1111111111111110, posun o 3 bity vpravo, pozície doplnené o jednotky

Naopak pred posunom najľavejší (najpravejší) bit je poslaný do “ríše zabudnutia”.

int a = 5;       // binarne: 0000000000000101
int b = a << 14; // binarne: 0100000000000000, prvá 1 v 101 bola odstránená

Bitový posun o jeden (binárny) rád vpravo, respektíve vľavo, má rovnaký význam, ako celočíselné delenie, respektíve násobenie, dvoma. Ak je bitový posun o viac než jeden rád, jedná sa o násobenie (delenie) príslušnou mocninou dvoch.

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

& and

Ak sú oba vstupné bity 1, výsledný výstup je 1, v opačnom prípade je výstup 0.

0  0  1  1    operand1
0  1  0  1    operand2
----------
0  0  0  1    (operand1 & operand2) - výsledok

Tu máme príklad:

int a =  92;    // binárne:  0000000001011100
int b = 101;    // binárne:  0000000001100101
int c = a & b;  // výsledok: 0000000001000100, alebo 68 v desiatkovej sústave

Každý zo 16 bitov v a a b sú spracovávané pomocou bitového súčinu a výsledok je uložený do c, čo je hodnota 01000100 binárne alebo 68 v desiatkovej sústave.

| or

Bitový súčet dvoch bitov je 1, ak jeden alebo oba zo vstupných bitov je 1, v opačnom prípade je 0.

0  0  1  1    operand1
0  1  0  1    operand2
----------
0  1  1  1    (operand1 | operand2) - výsledok

Tu máme príklad:

int a =  92;    // binárne:  0000000001011100
int b = 101;    // binárne:  0000000001100101
int c = a | b;  // výsledok: 0000000001111101, alebo 125 v desiatkovej sústave

Tieto bitové operácie sa najčastejšie využívajú pri maskovaní bitov na portoch.

^ xor

Toto je trochu neobvyklý operátor s názvom EXCLUSIVE OR, tiež známy ako bitový XOR. Bitový operátor XOR je napísaný pomocou symbolu striešky ^. Tento operátor je veľmi podobný bitovému operátoru or |, iba vyhodnotí 0 pre danú bitovú pozíciu, keď oba vstupné bity na tejto pozícii sú 1:

0  0  1  1    operand1
0  1  0  1    operand2
----------
0  1  1  0    (operand1 ^ operand2) - výsledok

Tu máme príklad:

int x = 12;     // binárne:  1100
int y = 10;     // binárne:  1010
int z = x ^ y;  // výsledok: 0110, alebo 6 v desiatkovej sústave

Ďalší spôsob, ako sa pozerať na bitový operátor XOR je to, že každý bit vo výsledku je 1 v prípade, že vstupné bity sú rôzne, alebo 0 v prípade, že sú rovnaké.

~ not

Bitové not ~ je operátorom unárnym, prevádza negáciu každého bitu v bitovom reťazci jediného operandu. Tomuto operátoru sa často hovorí bitový doplnok.

0  1    operand1   
----
1  0   (~ operand1) - výsledok

Tu máme príklad:

int a = 103;    // binárne:  0000000001100111
int b = ~a;     // binárne:  1111111110011000 = -104

Tiež ste prekvapení, že výsledok tejto operácie je záporné číslo -104? Je to preto, že najvyšší bit v int premennej je tzv. bit znamienka. V prípade, že najvyšší bit je 1, číslo je interpretované ako záporné. Toto kódovanie kladných a záporných čísel je označované ako dvojkový doplnok.

Mimochodom, je zaujímavé poznamenať, že ak na akékoľvek celé číslo x aplikujeme ~x, je výsledok rovnaký ako -x – 1.

Tento text je preložený a upravený zo stránok arduino.cc pod licenciou Creative Commons Attribution-ShareAlike 3.0.