> ## 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++ Left Shift The `<<` operator in C++ is a binary operator that serves two distinct structural purposes depending on its operand types: natively, it functions as the **bitwise left shift** operator for integral types, and through operator overloading, it acts as the **stream insertion** operator for output streams. ## 1. Bitwise Left Shift (Native Behavior) When both operands are integral or unscoped enumeration types, `<<` performs a bitwise left shift. It shifts the binary representation of the left-hand side (LHS) operand to the left by the number of positions specified by the right-hand side (RHS) operand. **Mechanics:** * **Zero-filling:** Vacated bit positions on the right are filled with zeros. * **Promotion:** Integer promotions are performed on both operands before the shift. The return type is the type of the promoted LHS operand. * **Mathematical Equivalence:** Shifting left by $n$ positions is mathematically equivalent to multiplying the LHS by $2^n$, provided no overflow occurs. * **Undefined Behavior (UB):** The operation results in UB if the RHS is negative, or if the RHS is greater than or equal to the bit-width of the promoted LHS type. ```cpp theme={"dark"} #include int main() { uint8_t a = 0b00001101; // Decimal 13 // 'a' undergoes integer promotion to 'int' before the shift. // The result is explicitly cast back to uint8_t for this assignment. uint8_t b = static_cast(a << 2); // Evaluates to 0b00110100 (Decimal 52) return 0; } ``` ## 2. Stream Insertion (Overloaded Behavior) When the LHS operand is an instance of `std::ostream` (such as `std::cout`), the `<<` operator is overloaded to perform stream insertion. It formats the RHS operand into a sequence of characters and inserts them into the stream buffer. The standard library implements this via two mechanisms: 1. **Member function overloads:** Used for fundamental types (e.g., `int`, `double`, `bool`) and `const void*`. 2. **Non-member function overloads:** Used for standard library types (e.g., `std::string`, `const char*`) to allow the stream to remain the LHS operand without modifying the `std::ostream` class itself. **Mechanics:** * **Return by Reference:** The operator strictly returns a reference to the LHS `std::ostream` object (`std::ostream&`), which enables operator chaining. * **Associativity vs. Evaluation Order:** The left-to-right associativity of `<<` dictates the *parsing and grouping* of the expression (i.e., `a << b << c` parses as `(a << b) << c`). However, associativity does not govern the *evaluation order* of the operands. Prior to C++17, the evaluation of arguments in a chained `<<` expression was unsequenced. Since C++17, the `<<` operator guarantees strict left-to-right sequential evaluation of its operands. ```cpp theme={"dark"} #include #include // Example of a user-defined non-member overload struct CustomData { int id; }; std::ostream& operator<<(std::ostream& os, const CustomData& data) { return os << data.id; } int main() { int var1 = 42; std::string var2 = " items: "; CustomData data{7}; // Chaining stream insertions std::cout << var1 << var2 << data << '\n'; // Structural equivalent demonstrating parsing and overload resolution: // 1. std::cout.operator<<(var1) -> member overload for 'int' // 2. operator<<(..., var2) -> non-member overload for 'std::string' // 3. operator<<(..., data) -> user-defined non-member overload // 4. operator<<(..., '\n') -> non-member overload for 'char' operator<<( operator<<( operator<<( std::cout.operator<<(var1), var2), data), '\n'); return 0; } ``` ## Precedence and Associativity Regardless of whether it is used for bitwise shifting or stream insertion, the `<<` operator maintains the same parsing rules in the C++ grammar: * **Associativity:** Left-to-right. * **Precedence:** It sits below arithmetic operators (`+`, `-`, `*`, `/`) but above relational operators (`<`, `>`, `<=`, `>=`) and equality operators (`==`, `!=`). Because of this precedence level, arithmetic expressions on the RHS of a stream insertion do not require parentheses, whereas bitwise operations, relational operations, or equality operations passed into a stream *do* require parentheses to prevent compilation errors or unintended parsing. ```cpp theme={"dark"} #include int main() { int val = 4; int a = 1; int b = 1; // Precedence mechanics std::cout << 5 + 3 << '\n'; // Valid: Evaluates as std::cout << (5 + 3) std::cout << (val << 1) << '\n'; // Parentheses required: Bitwise shift inside stream insertion std::cout << (a == b) << '\n'; // Parentheses required: Equality operation inside stream insertion return 0; } ```

Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More