Reference   Language | Libraries | Comparison | Changes

Bitweises links- (<<) und bitweises rechtsschieben (>>)

Beschreibung

Aus dem The Bitmath Tutorial in The Playground

Es gibt zwei Bitschiebeoperatoren in C/C++: den linksschiebe- (<<) und den rechtsschiebeoperator (>>). Diese Operatoren bewirken, dass die Bits im linken Parameter um die Anzahl der Bits im rechten Parameter nach rechts oder links geschoben werden.

Weitere Details zu Bit-Operationen finden sich hier.

Syntax

Variable << Anzahl_der_Bits

Variable >> Anzahl_der_Bits

Parameter

Variable - (byte, int, long) Anzahl_der_Bits integer <= 32

Beispiel

    int a = 5;        // binär: 0000000000000101
    int b = a << 3;   // binär: 0000000000101000, oder 40 in dezimal
    int c = b >> 3;   // binär: 0000000000000101, oder zurück zu 5 wie am Anfang

Wenn man den Wert x um y Bits nach links schiebt (x << y), gehen die Bits auf der linken Seite verloren, weil diese aus dem Wertebereich der Zahl geschoben werden:

    int a = 5;        // binär: 0000000000000101
    int b = a << 14;  // binär: 0100000000000000 - die Erste 1 in 101 wurde "aus dem Byte geschoben"

Wenn man davon ausgeht, dass keine der Bits links des Wertes aus dem Byte herausgeschoben werden, dann kann man sich den << Operator etwas so vorstellen: Er multipliziert den linken Wert mit 2 hoch dem rechten Wert also so:

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

Wenn man x um y nach rechts schiebt (x>>y), dann hängt das genaue Ergebnis vom Datentyp des Wertes ab. Wenn es sich um einen "normalen" also signed integer handelt (int), dann wird das Signed-Bit immer mit nach rechts geschoben (signed extension):

    int x = -16;     // binär: 1111111111110000
    int y = x >> 3;  // binär: 1111111111111110

Meistens möchte man aber, dass das Signed-Bit nicht mitgeschoben wird, d.h. von links her werden 0en eingeschoben, indem man per typecast zuerts einen unsigned int daraus macht:

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

Wenn man weiß, dass die Signed extension keine Probleme bereiten wird, dann kann man den >> Operator als divisor verwenden. x wird geteilt durch 2 hoch y:

    int x = 1000;
    int y = x >> 3;   // integer division von 1000 geteilt durch 8, Ergebnis y = 125

Reference Home

Corrections, suggestions, and new documentation should be posted to the Forum.

The text of the Arduino reference is licensed under a Creative Commons Attribution-ShareAlike 3.0 License. Code samples in the reference are released into the public domain.

Share