> ## 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++ Bitwise OR
The `|` operator in C++ is the bitwise inclusive OR operator. It performs a logical disjunction on each corresponding pair of bits from two integral operands, yielding a new value where a bit is set to `1` if at least one of the corresponding bits in the operands is `1`, and `0` otherwise.
## Syntax
```cpp theme={"dark"}
result = expression1 | expression2;
```
## Bitwise Truth Table
The operator evaluates the operands at the binary level according to the following truth table:
\| Bit 1 (`expression1`) | Bit 2 (`expression2`) | Result (`|`) |
\| :---: | :---: | :---: |
\| `0` | `0` | `0` |
\| `0` | `1` | `1` |
\| `1` | `0` | `1` |
\| `1` | `1` | `1` |
## Type Requirements and Promotions
* **Valid Types:** The built-in `|` operator requires both operands to be of integral types (e.g., `int`, `char`, `long`, `unsigned`) or unscoped enumeration types.
* **Integer Promotion:** Before the operation is performed, C++ applies standard integer promotions. Operands smaller than `int` (like `char` or `short`) are promoted to `int` (or `unsigned int`).
* **Usual Arithmetic Conversions:** If the operands are of different types after promotion, the compiler applies usual arithmetic conversions to bring them to a common type, which also dictates the type of the evaluated result.
## Compound Assignment
C++ provides a compound assignment operator, `|=`, which applies the bitwise OR operation and assigns the result directly to the left operand.
```cpp theme={"dark"}
expression1 |= expression2;
```
While logically similar to the expanded form `expression1 = expression1 | expression2;`, there is a critical semantic difference regarding expression evaluation. In the compound assignment (`|=`), `expression1` is evaluated exactly **once**. In the expanded form, `expression1` is evaluated **twice**. This distinction is vital if `expression1` contains side effects. For example, `arr[i++] |= 5;` evaluates the index and increments `i` only once, whereas `arr[i++] = arr[i++] | 5;` evaluates the side effect twice.
## Evaluation Semantics
Unlike the logical OR operator (`||`), the bitwise OR operator (`|`) **does not short-circuit**. Both `expression1` and `expression2` are fully evaluated before the bitwise operation occurs, regardless of the value of the first operand. Furthermore, the evaluation order of the operands for the built-in `|` operator remains **unsequenced** across all C++ standards (including C++17 and later). The compiler is free to evaluate `expression1` before `expression2`, or vice versa.
## Operator Overloading
For user-defined types (classes, structs, or scoped enumerations), the `|` operator can be overloaded. When overloaded, it loses its strict bitwise semantics unless explicitly implemented to mimic them.
```cpp theme={"dark"}
// Example signature for a non-member overloaded | operator
ReturnType operator|(const CustomType& lhs, const CustomType& rhs);
```
Tired of Poor C++ Skills? Fix That With Deep Grasping!
Learn More
