bitwise left shift

Angol

Főnév

bitwise left shift (tsz. bitwise left shifts)

(informatika)

Bitwise Left Shift (`<<`) C++-ban

A bitwise left shift (<<) operátor egy szám bináris ábrázolását balra tolja a megadott számú bittel. Ez a művelet minden bitet balra tol, és a jobb oldali üres helyeket nullákkal tölti fel.

Balra tolás (`<<`) működése

A << operátor lényege: - Minden bit balra tolódik a megadott számú pozícióval. - A jobb oldali üres helyek mindig nullákkal töltődnek fel. - A bal oldalon lévő bitek elveszhetnek, ha azok túllépik a tárolható bitszámot (overflow veszély!). - Matematikailag a balra tolás egyenértékű egy hatványozott szorzással (2^n-nel szorozza a számot).

Példa balra tolásra

Ha egy számot balra tolunk egy bittel (<< 1), az azt jelenti, hogy megduplázzuk.

#include <iostream>

int main() {
    int a = 5;  // 0101 binárisan
    int b = a << 1; // Egy bittel balra tolás

    std::cout << b << std::endl; // Kiírja: 10
    return 0;
}

Művelet lebontása:

  00000101  (5 decimálisan)
<< 1
-----------------
  00001010  (10 decimálisan)

Minden bit balra tolódik, és a jobb oldali üres helyek 0-val töltődnek fel.

Példa több bitnyi eltolásra

int c = 5 << 2; // 5 * 2^2 = 20 lesz az eredmény

  00000101  (5)
<< 2
-----------------
  00010100  (20)

Minden bit két helyet balra mozog, az eredmény meg-négyszereződik.

Balra tolás és szorzás kapcsolat

A balra tolás (<<) matematikailag egy hatványozott szorzás: - x << 1 ugyanaz, mint x * 2 - x << 2 ugyanaz, mint x * 4 - x << n ugyanaz, mint x * (2^n)

Példák:

int a = 3 << 1; // 3 * 2 = 6
int b = 3 << 2; // 3 * 4 = 12
int c = 3 << 3; // 3 * 8 = 24

Ezért a << operátor gyakran gyorsabb, mint a szorzás (*), mert a legtöbb CPU gyorsabban tudja eltolni a biteket, mint szorozni.

Figyelem: Overflow veszély!

A balra tolás veszélyes lehet, ha a szám túl nagy, és a legfelső bit kilép a hatókörből.

#include <iostream>
#include <climits>

int main() {
    int a = 1073741824; // 2^30
    int b = a << 1;  // Túllépés történik (overflow)

    std::cout << b << std::endl; // Az eredmény meglepő lehet!
    return 0;
}

Ha egy 32 bites egész számon dolgozunk, a balra tolás a legfelső bitet elveszítheti, és hibás eredményeket kaphatunk.

Megoldás: Használjunk előjel nélküli (`unsigned`) típust

unsigned int a = 1073741824; // 2^30
unsigned int b = a << 1; // Még mindig érvényes számítás

Hol használjuk a balra tolást?

Gyors szorzás: x << n gyorsabb, mint x * (2^n).

Bitmaskok létrehozása: Egy adott bit bekapcsolásához.

int mask = 1 << 3; // A 3. bit bekapcsolása: 00001000

Alacsony szintű programozás: Hardvervezérléshez, memóriacímzéshez.

Összegzés

A balra tolás (<<) minden bitet balra tol, a jobb oldalt nullákkal tölti fel.
Matematikailag egy 2^n-szeres szorzással egyenértékű.
Előjel nélküli (unsigned) típusok esetén biztonságosabb.
Veszély: Ha egy bit túlcsordul (overflow), az eredmény hibás lehet.

Ezt a műveletet gyakran használjuk optimalizálásra, bitmaskokra és hardverprogramozásra!

További információk

bitwise left shift - Szótár.net (en-hu)
bitwise left shift - Sztaki (en-hu)
bitwise left shift - Merriam–Webster
bitwise left shift - Cambridge
bitwise left shift - WordNet
bitwise left shift - Яндекс (en-ru)
bitwise left shift - Google (en-hu)
bitwise left shift - Wikidata
bitwise left shift - Wikipédia (angol)