Bitwise AND Assignment

The &= operator is the bitwise AND assignment operator in C++. It performs a bitwise AND operation between the left-hand operand (lhs) and the right-hand operand (rhs), and assigns the resulting value directly to the left-hand operand.

lhs &= rhs;

Semantically, this operation is equivalent to lhs = lhs & rhs, with the strict guarantee that the lhs expression is evaluated exactly once. This single-evaluation rule is critical when lhs contains side effects, such as an inline increment or a function call (e.g., arr[i++] &= 0x0F).

Type Requirements

For the built-in operator, both operands must be of integral or unscoped enumeration types. If the operands are of different types, standard integer promotions and usual arithmetic conversions are applied to align their types before the bitwise operation occurs. The operator can also be overloaded for user-defined types by defining operator&=.

Bit-Level Mechanics

The operation compares the operands bit by bit based on their binary representations. A bit in the resulting value is set to 1 if and only if the corresponding bits in both the lhs and rhs are 1. If either bit is 0, the resulting bit is 0.

#include <cstdint>

uint8_t a = 14; // Binary: 0000 1110
uint8_t b = 11; // Binary: 0000 1011

a &= b;         // Binary: 0000 1010 (Decimal: 10)

Return Value

The built-in &= operator modifies the lhs in place and returns an lvalue reference to the modified lhs. Because it returns an lvalue reference, the operator supports chaining, which evaluates right-to-left.

int x = 15; // 1111
int y = 7;  // 0111
int z = 3;  // 0011

x &= y &= z; 
// 1. y &= z evaluates first. 'y' becomes 3 (0011). Returns reference to 'y'.
// 2. x &= y evaluates next. 'x' becomes 3 (0011). Returns reference to 'x'.

Master C++ with Deep Grasping Methodology!

Learn More