Operator Overloading

Operator Overloading in C++

---

Prerequisites

---

1. What is Operator Overloading

Operator overloading allows you to define custom behavior for operators (+, -, *, ==, etc.) on user-defined types.

Category	Operators
Arithmetic	+ - * /
Comparison	== != < > <= >=
Assignment	= += -=
Increment	++ --
Access	[] () ->
Stream	<< >>

Makes code more intuitive and expressive.

✔ Without overloading

Vector c = add(a, b);

✔ With overloading

Vector c = a + b;

Cleaner and closer to mathematical notation

2. Operator Overloading

2-1. Basic Syntax

return_type operatorOP(parameters) 
{
    // implementation
}

Example:

class Vec 
{
public:
    int x, y;

    Vec operator+(const Vec& other) const 
    {
        return {x + other.x, y + other.y};
    }
};

2-2. Member/Non-member

✔ Member function

Vec operator+(const Vec& other) const;

Left operand = object itself

✔ Non-member (free function)

Vec operator+(const Vec& a, const Vec& b);

More flexible (especially for symmetry)

Case	Recommendation
Access private members	Member or friend
Symmetric operation	Non-member
Assignment-like (=)	Member

2-3. Example

class Vec 
{
public:
    Vec(float x, float y) : x(x), y(y) {}

    Vec operator+(const Vec& other) const 
    {
        return Vec(x + other.x, y + other.y);
    }

    Vec operator*(float scalar) const 
    {
        return Vec(x * scalar, y * scalar);
    }

public:
    float x, y;
};

Stream Operator (<<)

✔ Must be non-member

#include <iostream>

std::ostream& operator<<(std::ostream& os, const Vec& v) 
{
    os << "(" << v.x << ", " << v.y << ")";
    return os;
}

Comparison Operator

bool operator==(const Vec& other) const 
{
    return x == other.x && y == other.y;
}

Assignment Operator

Vec& operator=(const Vec& other) 
{
    if (this != &other) 
    {
        x = other.x;
        y = other.y;
    }

    return *this;
}

Must return reference

Increment Operator

✔ Prefix

Vec& operator++() 
{
    x++; y++;

    return *this;
}

✔ Postfix

Vec operator++(int) 
{
    Vec temp = *this;
    ++(*this);
    return temp;
}

int is dummy parameter

Subscript Operator

int& operator[](int index) 
{
    if (index == 0) 
        return x;

    return y;
}

Function Call Operator

class Functor 
{
public:
    int operator()(int x) 
    {
        return x * x;
    }
};

+Performance Considerations

Return by value (C++17 optimized)

Vec operator+(const Vec& other) const 
{
    return Vec(x + other.x, y + other.y);
}

Copy elision / move optimization

• Use const& for parameters
• Return by value (optimized)

✔ DO

• Keep semantics intuitive
• Use const correctness
• Prefer non-member for symmetric ops
• Keep operators lightweight

❌ DON’T

• Overload in confusing ways
• Hide expensive operations behind operators
• Break expected behavior

Bad Example: unexpected behavior

Vec operator+(const Vec& other) 
{
    sleep(1);  // ❌ unexpected behavior
    return ...
}