Shift-Right-Operator >>

Der Shift-Right-Operator verschiebt die Bits einer Integer-Zahl um eine gegebene Anzahl nach rechts und füllt die übrigen Bits mit 0 oder bei negativen Zahlen mit 1 auf. Die zu verändernde Zahl steht links des Operators, die Anzahl an zu verschiebender Bit-Stellen steht rechts des Operators.

01001001100101100000001011010010
00100100110010110000000101101001
00000010010011001011000000010110
10110110011010011111110100101110
11111101101100110100111111101001

#include <stdio.h>

void printbinary(int x){
  char str[33]; str[32] = '\0';
  int i = 32;
  while(i){i--; str[i] = (x & 1) + '0'; x>>=1;}
  printf("%s\n", str);
}

int main(){
  int x = 1234567890;
  int y = -1234567890;
  printbinary(x);
  printbinary(x >> 1);
  printbinary(x >> 5);
  printbinary(y);
  printbinary(y >> 5);
  return 0;
}

In C++ wird der Shift-Right-Operator zudem oft mit der Eingabe von einem Stream in Zusammenhang gebracht.

Details

Der Shift-Right-Operator erwartet zwei Operanden als rvalues und wird von links nach rechts abgearbeitet. Der Rückgabewert ist ein rvalue, der stets ein Integer-Typ ist.

Der Shift-Right-Operator ist nur für Integer-Werte zulässig. Unter C++ ist zusätzlich auch die Anwendung des Operators auf boolsche Werte erlaubt, welche jedoch vor Anwendung des Operators in einen int umgewandelt werden.

Durch das Verschieben der Bits nach rechts werden die übrigbleibenden Stellen am linken Ende mit 0 aufgefüllt. Dies entspricht einem logischen Bitshift in Assembler. Handelt es sich bei dem Typ des ersten Operanden jedoch um einen signed-Typ, so wird das Sign-Bit (höchstwertiges Bit) kopiert. Dadurch bleiben negative Zahlen negativ, was einem arithmetischen Bitshift in Assembler entspricht. Der Shift-Right-Operator wird oftmals mittels SHR abgekürzt.

01001001100101100000001011010010
00000010010011001011000000010110
11101110011010110010100000000000
00000111011100110101100101000000
01001001100101100000001011010010
00000010010011001011000000010110
10110110011010011111110100101110
11111101101100110100111111101001

unsigned  int x = 1234567890;
unsigned  int y = 4000000000;
signed    int z = 1234567890;
signed    int w = -1234567890;
printbinary(x);
printbinary(x >> 5);
printbinary(y);
printbinary(y >> 5);
printbinary(z);
printbinary(z >> 5);
printbinary(w);
printbinary(w >> 5);

Ist die Anzahl zu verschiebender Bits negativ oder grösser als die Länge des verwendeten integer-Typs in Bits, so ist das Resultat nicht spezifiziert. Je nach Compiler können andere Resultate entstehen. In GCC beispielsweise wird die Anzahl zu verschiebender Bits als unsigned-Zahl aufgefasst und modulo der Registerbreite in Bits gerechnet, allerdings gibt der Compiler eine Warnung aus.

Die Operatoren << und >> werden hauptsächlich für low-level Programmierung verwendet, wie beispielsweise in der Systemprogrammierung. Da sie einzelne Bits verändern, wird der Umgang mit diesen Operatoren auch häufig als Bit-fiddling (Bit-Schwindeleien, auch zu verstehen als Bit-Gebastel, oder auf gut Schweizerdeutsch: Umegfätterle mit Bittli) bezeichnet. In der alltäglichen Programmierung finden diese beiden Operatoren heutzutage kaum mehr Verwendung.

Eine heute ab und zu noch anzutreffende Verwendung des Shift-Right-Operators ist die Division einer Zahl mit einer Potenz von 2. Durch die Verschiebung mit 0, 1, 2, 3, ... Bits wird der erste Operand mit 1, 2, 4, 8, ... dividiert. In früheren Zeiten war dies die bevorzugte Art, Zahlen mit einer Potenz von 2 zu dividieren, da ein Bitshift vom Prozessor schneller berechnet werden konnte als eine Division. In heutigen Prozessoren spielt dies keine Rolle mehr.

336
168
84
42

printf("%d\n", 336 >> 0);
printf("%d\n", 336 >> 1);
printf("%d\n", 336 >> 2);
printf("%d\n", 336 >> 3);