> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# C++ Right Shift Assignment
The `>>=` (right shift assignment) operator is a compound assignment operator that performs a bitwise right shift on its left operand by the number of bit positions specified by its right operand, subsequently assigning the computed result back to the left operand.
```cpp theme={"dark"}
lhs >>= rhs;
```
Semantically, the expression `lhs >>= rhs` is equivalent to `lhs = lhs >> rhs`, with the strict guarantee that the expression `lhs` is evaluated exactly once.
## Operand Constraints
The operands have distinct type requirements:
* **Left Operand (`lhs`):** Must be a modifiable lvalue of an **integral type** (e.g., `char`, `short`, `int`, `long`, `unsigned`). It cannot be an enumeration type, because C++ does not allow implicit conversions from the integer result of the shift operation back to an enumeration.
* **Right Operand (`rhs`):** Must be of an **integral type** or an **unscoped enumeration type** (which implicitly promotes to an integer).
While the underlying bitwise shift (`>>`) applies standard integer promotions to the operands before the shift operation occurs, the compound assignment operator converts the computed result back to the original type of `lhs`. The final result of the expression is an lvalue reference to the *unpromoted* left operand.
## Bit-Level Behavior
The treatment of the vacated Most Significant Bits (MSBs) depends strictly on the signedness of the left operand and the C++ standard version:
* **Unsigned Integers:** The operator performs a **logical right shift**. The vacated MSBs are unconditionally filled with zeros.
* **Signed Integers (Non-negative values):** The operator performs a logical right shift, filling vacated MSBs with zeros.
* **Signed Integers (Negative values):**
* **C++20 and later:** The operator is guaranteed to perform an **arithmetic right shift**. It utilizes sign-extension, filling the vacated MSBs with `1`s (the original sign bit). This is mathematically defined as division by $2^{rhs}$ rounding towards negative infinity.
* **Pre-C++20:** The behavior of right-shifting a negative signed integer is implementation-defined (though the vast majority of compilers historically implemented sign-extension).
## Undefined Behavior (UB)
The `>>=` operator invokes undefined behavior under the following conditions:
1. **Negative Shift Count:** The right operand (`rhs`) is less than `0`.
2. **Oversized Shift Count:** The right operand (`rhs`) is greater than or equal to the total number of bits in the *promoted* left operand. For example, if `lhs` promotes to a 32-bit integer, `lhs >>= 32` and `lhs >>= 33` result in undefined behavior.
## Return Value
The operator returns an lvalue reference to the modified left operand (`lhs`), allowing for operator chaining (e.g., `a >>= b >>= c`). Such chaining evaluates right-to-left due to the operator's right-associativity.
## Overloading
For user-defined types (classes or structs), the `>>=` operator can be overloaded by defining a function named `operator>>=`. When overloaded, the operator evaluates its operands exactly once as function arguments, preserving the standard single-evaluation guarantee.
```cpp theme={"dark"}
class T {
public:
T& operator>>=(const T2& rhs); // Typical signature for member overload
};
```
Tired of Poor C++ Skills? Fix That With Deep Grasping!
Learn More
