Shift-Right-Zuweisung >>=

Der Shift-Right-Zuweisungs-Operator verschiebt die Bits der Variablen, die links des Operators steht um die rechts des Operator stehende Anzahl Stellen nach rechts und speichert das Resultat zurück in die Variable.

01001001100101100000001011010010

00010010011001011000000010110100

#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 a = 1234567890;
  printbinary(a);
  a >>= 2;
  printbinary(a);
}

Siehe auch Zuweisungs-Operator =, Shift-Right-Operator >>

Details

Der Shift-Right-Zuweisungs-Operator erwartet links einen lvalue und rechts einen rvalue und wird von rechts nach links abgearbeitet. Der Rückgabewert ist in C ein rvalue: Der Wert des linken Operanden nach der Zuweisung. in C++ ist der Rückgabewert ein lvalue: Der (mittlerweile zugewiesene) linke Operand selbst.

Der Shift-Right-Zuweisungs-Operator verhält sich genau gleich wie der Zuweisungsoperator, nur dass er eine zusätzliche Shift-Right-Operation ausführt. Für Details über die Eigenschaften einer Shift-Right-Zuweisung wird hier somit auf die Beschreibung des Zuweisungsoperators und des Shift-Right-Operators verwiesen. Als zusätzliche Erläuterung des Shift-Right-Zuweisungs-Operators im Bezug zum einfachen Zuweisungsoperator genügen folgende zwei Programmzeilen, welche absolut äquivalent sind:

  a >>=       2;
  a   = a >> (2);

Die gesetzten runden Klammern deuten an, dass aufgrund der Operatoren-Rangordnung bei der Shift-Right-Zuweisung genauso wie bei allen Zuweisungs-Operatoren der komplette rechte Teil nach den Gleichheitszeichen als EIN Operand ausgewertet wird.

Überladen des Operators

Der Shift-Right-Zuweisungs-Operator hat grundsätzlich die semantische Bedeutung einer Shift-Right-Operation mit einem Wert und anschliessender Zuweisung des Resultates zur Variablen. Allerdings steht es dem Programmierer frei, eine andere Semantik zu definieren.

Es sei hier darauf hingewisesen, dass der Shift-Right-Zuweisungs-Operator äusserst selten überladen wird. Während der einfache Shift-Right-Operator >> in C++ für die Eingabe von einem Stream benutzt wird hat der Shift-Right-Zuweisungs-Operator keine spezielle Bedeutung.

Die Prototypen für das Überladen des Shift-Right-Zuweisungs-Operators sind die folgenden (Einschränkungen und Erläuterungen siehe Überladen von Operatoren):

inside class


outside class

Type operator >>=(Type);
Type operator >>=(Type) const;

Type operator >>=(Type, Type);

Man beachte, dass der Shift-Right-Zuweisungs-Operator im Gegensatz zum einfachen Zuweisungs-Operator sowohl innerhalb als auch ausserhalb der Klasse überladen werden kann, obschon gewisse Quellen dies nicht erlauben. Es ist jedoch grundsätzlich zu empfehlen, Zuweisungs-Operatoren nicht ausserhalb der Klasse zu definieren.

Da der Shift-Right-Zuweisungs-Operator in C++ normalerweise einen lvalue zurückgibt, ist der Rückgabetyp der Überladung üblicherweise ein Referenz-Typ (&) der eigenen Klasse, wobei der Rückgabewert normalerweise mit return *this angegeben wird.

Der const-Prototyp macht auf den ersten Moment keinen Sinn, da bei einer Zuweisung im herkömmlichen Sinne das betroffene Objekt immer verändert wird. Man beachte jedoch, dass Felder von Klassen mittels der mutable-Speicherklasse deklariert werden können, was es ermöglicht, einen Shift-Right-Zuweisungs-Operator als konstant zu deklarieren. Bei Auftreten beider Prototyp-Varianten in einer Klasse wird jedoch grundsätzlich (ohne die Notwendigkeit eines const-Aufrufes) die nicht-const-Überladung aufgerufen.

Im folgenden Beispiel wird eine Klasse für einen String präsentiert. Der überladene Shift-Right-Zuweisungs-Operator verschiebt die Buchstaben im String nach rechts und füllt die Zeichen links mit Leerzeichen auf.

Hello World!

   Hello World!

#include <cstdio>
#include <cstring>

class String{
  char str[20];
public:
  String(const char* newstr){
    strncpy(str, newstr, 19);
    str[strlen(newstr)] = '\0';
    str[19] = '\0';
  }
  void print(){printf("%s\n", str);}

  String& operator >>=(unsigned int shift){
    for(int i=19; i>=shift; i--){
      str[i] = str[i-shift];
    }
    for(int i=0; i<shift; i++){
      str[i] = ' ';
    }
    if(shift >= 20){str[0] = '\0';}
    str[19] = '\0';
    return *this;
  }
};

int main(){
  String s("Hello World!");
  s.print();
  s >>= 3;
  s.print();
  return 0;
}