Left And Right Arrows C++ Program

The left (<<) and right (>>) arrow symbols in C++ serve as powerful operators with dual functionalities. Understanding their distinct roles in bit manipulation and stream operations is fundamental for any C++ programmer. In this article, you will learn the different uses of these operators, how they work, and see practical examples.

Problem Statement

Efficient data manipulation at the bit level and streamlined input/output operations are common requirements in C++ programming. Without operators like << and >>, achieving these tasks would be more verbose and less intuitive, potentially impacting performance and code readability.

Example

Consider a scenario where you want to quickly multiply a number by a power of two or simply print text to the console.

// Basic Arrow Operator Examples
#include <iostream>
using namespace std;

int main() {
    int number = 10;

    // Use for output (stream insertion)
    cout << "Hello, C++!" << endl;

    // Use for bitwise left shift (multiplication by 2)
    int shiftedNumber = number << 1; // 10 * 2 = 20

    // Use for output again
    cout << "Original number: " << number << endl;
    cout << "Shifted number (x2): " << shiftedNumber << endl;

    return 0;
}

Run

Output:

Hello, C++!
Original number: 10
Shifted number (x2): 20

This brief example demonstrates the << operator's role in both printing output and performing bit-level shifts.

Background & Knowledge Prerequisites

To fully grasp the concepts discussed in this article, readers should have a basic understanding of:

• C++ Variables and Data Types: int, char, bool, etc.
• Binary Numbers: How integers are represented in binary format (base 2).
• Basic I/O: Familiarity with cout and cin.
• Header Files: How #include directives work.

Use Cases or Case Studies

The left and right arrow operators are versatile and appear in various C++ programming contexts:

• Efficient Bitwise Manipulation: Performing fast multiplication or division by powers of 2, setting/clearing specific bits, or checking bit states.
• Standard Input/Output: The most common use for cout (console output) and cin (console input).
• Data Serialization/Deserialization: Packing and unpacking data into/from byte streams for network communication or file storage.
• Flag Management: Using individual bits in an integer to represent multiple boolean flags, which can be manipulated efficiently with shifts.
• Custom Stream Operators: Overloading << and >> to allow custom classes to be easily printed to or read from streams.

Solution Approaches

Let's explore the primary applications of the << and >> operators.

Approach 1: Bitwise Left Shift (<<) Operator

This operator shifts the bits of the left operand to the left by the number of positions specified by the right operand. Vacated bits on the right are filled with zeros. Effectively, a left shift by n positions multiplies the number by 2^n.

• One-line summary: Shifts bits to the left, equivalent to multiplying by powers of 2.

// Bitwise Left Shift Example
#include <iostream>
#include <bitset> // For binary representation

int main() {
    int num = 5; // Binary: 00000101

    std::cout << "Original number: " << num << " (Binary: " << std::bitset<8>(num) << ")" << std::endl;

    // Shift left by 1 position (5 * 2^1 = 10)
    int shiftedLeft1 = num << 1;
    std::cout << "Shifted left by 1: " << shiftedLeft1 << " (Binary: " << std::bitset<8>(shiftedLeft1) << ")" << std::endl;

    // Shift left by 3 positions (5 * 2^3 = 40)
    int shiftedLeft3 = num << 3;
    std::cout << "Shifted left by 3: " << shiftedLeft3 << " (Binary: " << std::bitset<8>(shiftedLeft3) << ")" << std::endl;

    return 0;
}

Run

Sample Output:

Original number: 5 (Binary: 00000101)
Shifted left by 1: 10 (Binary: 00001010)
Shifted left by 3: 40 (Binary: 00101000)

Stepwise Explanation:

1. Initialize an integer num to 5, which is 00000101 in 8-bit binary.
2. shiftedLeft1 = num << 1;: The bits of 00000101 are shifted one position to the left. The leftmost bit (0) is discarded, and a 0 is added to the rightmost position, resulting in 00001010, which is decimal 10.
3. shiftedLeft3 = num << 3;: The bits of 00000101 are shifted three positions to the left. Three leftmost bits are discarded, and three 0s are added to the right, yielding 00101000, which is decimal 40.

Approach 2: Bitwise Right Shift (>>) Operator

This operator shifts the bits of the left operand to the right by the number of positions specified by the right operand. Vacated bits on the left are filled based on the type: with zeros for unsigned types, and with the sign bit (arithmetic shift) or zeros (logical shift) for signed types (implementation-defined for signed integers, but usually arithmetic). Effectively, a right shift by n positions divides the number by 2^n.

• One-line summary: Shifts bits to the right, equivalent to dividing by powers of 2.

// Bitwise Right Shift Example
#include <iostream>
#include <bitset> // For binary representation

int main() {
    unsigned int positiveNum = 40; // Binary: 00101000
    int negativeNum = -40;       // Example (system dependent): 11011000 (Two's complement for 8-bit)

    std::cout << "Original positive number: " << positiveNum << " (Binary: " << std::bitset<8>(positiveNum) << ")" << std::endl;

    // Shift right by 1 position (40 / 2^1 = 20)
    unsigned int shiftedRight1 = positiveNum >> 1;
    std::cout << "Shifted right by 1: " << shiftedRight1 << " (Binary: " << std::bitset<8>(shiftedRight1) << ")" << std::endl;

    // Shift right by 3 positions (40 / 2^3 = 5)
    unsigned int shiftedRight3 = positiveNum >> 3;
    std::cout << "Shifted right by 3: " << shiftedRight3 << " (Binary: " << std::bitset<8>(shiftedRight3) << ")" << std::endl;

    std::cout << "\\nOriginal negative number: " << negativeNum << " (Binary: " << std::bitset<8>(negativeNum) << ")" << std::endl;
    int shiftedNegative = negativeNum >> 1; // Arithmetic shift (preserves sign)
    std::cout << "Shifted negative by 1: " << shiftedNegative << " (Binary: " << std::bitset<8>(shiftedNegative) << ")" << std::endl;

    return 0;
}

Run

Sample Output (might vary for negative numbers based on system):

Original positive number: 40 (Binary: 00101000)
Shifted right by 1: 20 (Binary: 00010100)
Shifted right by 3: 5 (Binary: 00000101)

Original negative number: -40 (Binary: 11011000)
Shifted negative by 1: -20 (Binary: 11101100)

Stepwise Explanation:

1. Initialize positiveNum to 40 (00101000 binary).
2. shiftedRight1 = positiveNum >> 1;: Bits are shifted one position to the right. The rightmost bit (0) is discarded, and a 0 is added to the leftmost position (for unsigned types), resulting in 00010100, which is decimal 20.
3. shiftedRight3 = positiveNum >> 3;: Bits are shifted three positions to the right. Three rightmost bits are discarded, and three 0s are added to the left, yielding 00000101, which is decimal 5.
4. For signed negativeNum = -40 (e.g., 11011000 in 8-bit two's complement): shiftedNegative = negativeNum >> 1; performs an arithmetic right shift. The sign bit (1) is replicated on the left, resulting in 11101100, which is decimal -20.

Approach 3: Stream Insertion (<<) and Extraction (>>) Operators

These operators are overloaded in the iostream library to facilitate easy input and output operations. << is the stream insertion operator (often called "put to"), used to send data to an output stream (like cout). >> is the stream extraction operator (often called "get from"), used to read data from an input stream (like cin).

• One-line summary: Used for input (from cin) and output (to cout) with streams.

// Stream Operators Example
#include <iostream>
#include <string>

int main() {
    std::string name;
    int age;

    // Use << for output (stream insertion)
    std::cout << "Please enter your name: ";

    // Use >> for input (stream extraction)
    std::cin >> name;

    std::cout << "Please enter your age: ";
    std::cin >> age;

    // Combine << operators for chained output
    std::cout << "Hello, " << name << "! You are " << age << " years old." << std::endl;

    return 0;
}

Run

Sample Output (user input bold):

Please enter your name: **Alice**
Please enter your age: **30**
Hello, Alice! You are 30 years old.

Stepwise Explanation:

1. std::cout << "Please enter your name: ";: The string literal is inserted into the std::cout output stream, which typically prints to the console.
2. std::cin >> name;: Data is extracted from the std::cin input stream (typically keyboard input) and stored into the name string variable.
3. std::cin >> age;: Similarly, integer data is extracted from std::cin and stored in the age integer variable.
4. The final std::cout line demonstrates chaining multiple << operators to print various data types and string literals in sequence. std::endl inserts a newline character and flushes the buffer.

Approach 4: Operator Overloading

C++ allows you to overload operators for custom classes. This means you can define how << and >> behave when used with objects of your own types, making them seamlessly integrate with standard I/O streams.

• One-line summary: Define custom behavior for stream I/O with user-defined types.

// Operator Overloading Example
#include <iostream>
#include <string>

class Person {
public:
    std::string name;
    int age;

    Person(std::string n = "Unknown", int a = 0) : name(n), age(a) {}

    // Friend function to overload << for output
    friend std::ostream& operator<<(std::ostream& os, const Person& p) {
        os << "Name: " << p.name << ", Age: " << p.age;
        return os;
    }

    // Friend function to overload >> for input
    friend std::istream& operator>>(std::istream& is, Person& p) {
        std::cout << "Enter person's name: ";
        is >> p.name;
        std::cout << "Enter person's age: ";
        is >> p.age;
        return is;
    }
};

int main() {
    Person p1("John Doe", 25);
    Person p2; // Default constructor

    // Using overloaded << to print
    std::cout << "Person 1 details: " << p1 << std::endl;

    // Using overloaded >> to read input
    std::cout << "\\nEnter details for Person 2:\\n";
    std::cin >> p2;

    // Using overloaded << to print Person 2
    std::cout << "\\nPerson 2 details: " << p2 << std::endl;

    return 0;
}

Run

Sample Output (user input bold):

Person 1 details: Name: John Doe, Age: 25

Enter details for Person 2:
Enter person's name: **Jane Smith**
Enter person's age: **32**

Person 2 details: Name: Jane Smith, Age: 32

Stepwise Explanation:

1. A Person class is defined with name and age members.
2. The operator<< function is overloaded as a friend function. It takes an ostream reference and a const Person& reference, prints the person's details to the stream, and returns the stream reference, allowing chaining.
3. The operator>> function is overloaded, also as a friend. It takes an istream reference and a Person& reference, prompts for input, reads into the Person object, and returns the stream reference.
4. In main, objects p1 and p2 are created. The overloaded operators are then used naturally with std::cout and std::cin to print and read Person objects.

Conclusion

The "left and right arrows" in C++ (<< and >>) are powerful, context-dependent operators. They are essential for performing efficient bitwise manipulations, which can optimize certain numerical computations, and are fundamental to C++'s standard input/output system, providing a clean and intuitive way to interact with streams. Their ability to be overloaded also extends this versatility to user-defined types, making C++ code more readable and consistent.

Summary

• The << operator performs bitwise left shift (multiplies by powers of 2) or stream insertion (output to streams like cout).
• The >> operator performs bitwise right shift (divides by powers of 2) or stream extraction (input from streams like cin).
• Bitwise shifts are efficient for multiplying/dividing integers by powers of two and for low-level bit manipulation.
• Stream operators are ubiquitous for standard I/O operations in C++.
• Both operators can be overloaded to extend their functionality to custom classes, enhancing code readability and integration with C++ streams.