Operator Overloading

🎭 C++ Operator Overloading: Teaching Your Classes New Tricks!

The Magic Analogy: Think of a class like a pet dog. By default, your dog knows basic things. But with training, you can teach it new tricks! Operator overloading is like teaching your C++ classes new tricks—making +, -, ==, and other symbols do exactly what YOU want!

🌟 What is Operator Overloading?

Imagine you have two toy boxes. You want to combine them into one big toy box. In real life, you’d just pour toys together. But in C++, the computer doesn’t know how to “add” toy boxes!

Operator overloading lets you tell C++: “Hey, when I use + with my ToyBox objects, here’s what I want you to do!”

The Simple Truth

// Without overloading - ERROR! ❌
ToyBox box1, box2;
ToyBox combined = box1 + box2; // C++ says "I don't know how!"

// WITH overloading - WORKS! ✅
// You teach C++ what + means for ToyBox
ToyBox combined = box1 + box2; // Now it works!

🎯 Why Do We Need This?

Much cleaner, right? It makes your code read like natural language!

🔢 Arithmetic Overloading (+, -, *, /)

Let’s create a Point class and teach it math!

The Story

Picture two dots on a piece of paper. Each dot has an X and Y position. What if you want to move one dot by adding another dot’s position to it?

class Point {
public:
    int x, y;

    Point(int x = 0, int y = 0)
        : x(x), y(y) {}

    // Teaching Point how to ADD! 🎉
    Point operator+(const Point& other) {
        return Point(x + other.x,
                     y + other.y);
    }

    // Teaching Point how to SUBTRACT!
    Point operator-(const Point& other) {
        return Point(x - other.x,
                     y - other.y);
    }
};

Using It!

Point a(3, 4);
Point b(1, 2);

Point c = a + b;  // c is (4, 6)
Point d = a - b;  // d is (2, 2)

🖼️ Visual Flow

graph TD
    A["Point a: 3,4"] --> C["operator+"]
    B["Point b: 1,2"] --> C
    C --> D["New Point: 4,6"]

⚖️ Comparison Overloading (==, !=, <, >, <=, >=)

The Story

Imagine you have two apples. How do you know if they’re the same? You check their color, size, and type! Comparison overloading teaches your class how to compare itself with others.

class Student {
public:
    string name;
    int grade;

    Student(string n, int g)
        : name(n), grade(g) {}

    // Are two students equal?
    bool operator==(const Student& other) {
        return name == other.name &&
               grade == other.grade;
    }

    // Is this student "less than" another?
    // (by grade)
    bool operator<(const Student& other) {
        return grade < other.grade;
    }

    // Not equal
    bool operator!=(const Student& other) {
        return !(*this == other);
    }
};

Using It!

Student alice("Alice", 95);
Student bob("Bob", 87);
Student alice2("Alice", 95);

if (alice == alice2) {
    cout << "Same student!";  // ✅ Prints!
}

if (bob < alice) {
    cout << "Bob has lower grade";  // ✅ Prints!
}

📋 Assignment Overloading (=)

The Story

When you copy homework, you don’t just take the original paper—you write everything onto YOUR paper. Assignment overloading tells C++ HOW to copy one object into another.

⚠️ The Rule of Three

If your class has pointers or manages memory, you NEED a custom assignment operator!

class MyString {
    char* data;
    int length;

public:
    // Assignment operator
    MyString& operator=(const MyString& other) {
        // Step 1: Check self-assignment!
        if (this == &other) {
            return *this;
        }

        // Step 2: Clean up old data
        delete[] data;

        // Step 3: Copy new data
        length = other.length;
        data = new char[length + 1];
        strcpy(data, other.data);

        // Step 4: Return yourself
        return *this;
    }
};

🎯 Key Points

📦 Subscript Overloading ([])

The Story

Think of a bookshelf. You say “give me book number 3” and point to the third slot. The [] operator lets you access items by position—and you can customize how it works!

class SafeArray {
    int arr[100];
    int size;

public:
    SafeArray() : size(100) {
        for(int i = 0; i < 100; i++)
            arr[i] = 0;
    }

    // Subscript operator (read/write)
    int& operator[](int index) {
        if (index < 0 || index >= size) {
            cout << "Error: Bad index!";
            return arr[0];  // Safe fallback
        }
        return arr[index];
    }

    // Const version (read-only)
    const int& operator[](int index) const {
        if (index < 0 || index >= size) {
            cout << "Error: Bad index!";
            return arr[0];
        }
        return arr[index];
    }
};

Using It!

SafeArray nums;
nums[5] = 42;       // Write to position 5
int x = nums[5];    // Read from position 5
nums[200] = 10;     // Prints error, safe!

🎯 Functor Overloading (())

The Story

A functor is an object that acts like a function! Imagine a robot that you can program to do different tasks. You call it like a function, but it’s actually an object with memory!

class Multiplier {
    int factor;

public:
    Multiplier(int f) : factor(f) {}

    // The magic () operator!
    int operator()(int x) {
        return x * factor;
    }
};

Using It!

Multiplier times3(3);
Multiplier times5(5);

int result1 = times3(10);  // 30
int result2 = times5(10);  // 50

// It's an object that acts like a function!

🌟 Why Functors Rock

graph TD
    A["Regular Function"] --> B["No State"]
    C["Functor Object"] --> D["Has State!"]
    D --> E["Remembers Things"]
    D --> F["Can Be Customized"]

Functors can remember things between calls!

📺 Stream Overloading (<< and >>)

The Story

When you want to print your object or read into it, wouldn’t it be nice to use cout and cin naturally? Stream operators let you do exactly that!

class Person {
public:
    string name;
    int age;

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

    // Friend function for output <<
    friend ostream& operator<<(
        ostream& out,
        const Person& p
    ) {
        out << p.name << " (" << p.age << ")";
        return out;
    }

    // Friend function for input >>
    friend istream& operator>>(
        istream& in,
        Person& p
    ) {
        in >> p.name >> p.age;
        return in;
    }
};

Using It!

Person bob("Bob", 25);

// Output - so clean!
cout << bob << endl;
// Prints: Bob (25)

// Input
Person someone;
cin >> someone;  // Type: Alice 30

🔑 Key Insight

Stream operators are usually friend functions (not members) because the left side is cout/cin, not your object!

🔄 Conversion Operators

The Story

Sometimes you want your object to become another type. Like a caterpillar becoming a butterfly! Conversion operators let your class transform into other types automatically.

class Fraction {
    int num, den;

public:
    Fraction(int n, int d)
        : num(n), den(d) {}

    // Convert to double automatically!
    operator double() const {
        return (double)num / den;
    }

    // Convert to bool (is it non-zero?)
    operator bool() const {
        return num != 0;
    }
};

Using It!

Fraction half(1, 2);

// Automatic conversion to double!
double d = half;     // d = 0.5
cout << half + 1.0;  // Prints 1.5

// Automatic conversion to bool!
if (half) {
    cout << "Not zero!";  // ✅ Prints!
}

Fraction zero(0, 1);
if (!zero) {
    cout << "It's zero!";  // ✅ Prints!
}

⚠️ Use explicit for Safety

class SafeFraction {
public:
    // Only convert when explicitly asked
    explicit operator double() const {
        return (double)num / den;
    }
};

SafeFraction f(1, 2);
double d = (double)f;  // ✅ Works
double e = f;          // ❌ Error! Good!

🎨 The Complete Picture

graph LR
    A["Operator Overloading"] --> B["Arithmetic"]
    A --> C["Comparison"]
    A --> D["Assignment"]
    A --> E["Subscript"]
    A --> F["Functor"]
    A --> G["Stream"]
    A --> H["Conversion"]

    B --> B1["+, -, *, /"]
    C --> C1["==, !=, <, >"]
    D --> D1["= for deep copy"]
    E --> E1["[] for indexing"]
    F --> F1["#40;#41; makes callable"]
    G --> G1["<<, >> for I/O"]
    H --> H1["Type transforms"]

🚀 Golden Rules

1. Keep it intuitive - + should add, not subtract!
2. Be consistent - If you overload ==, also do !=
3. Return references when chaining (=, +=)
4. Return by value for arithmetic (+, -)
5. Use const for read-only operations
6. Friend functions for stream operators

🎯 Quick Reference

🌈 You Did It!

You now understand operator overloading! Your classes can:

• ✅ Do math with +, -, *, /
• ✅ Compare themselves with ==, <
• ✅ Copy properly with =
• ✅ Access items with []
• ✅ Act like functions with ()
• ✅ Print and read with <<, >>
• ✅ Transform into other types

Your C++ classes just learned amazing new tricks! 🎉