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.

#include <cstdint>

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<uint8_t>(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.

#include <iostream>
#include <string>

// 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.

#include <iostream>

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;
}

Master C++ with Deep Grasping Methodology!

Learn More