Module 19: Operator Overloading in C++

Operator Overloading allows predefined C++ operators to work with user-defined objects. It enables operators such as +, -, [], (), <<, ==, and != to perform meaningful operations on objects of custom classes.

For example, instead of writing:

cppCopy
1complex.add(other);

You can write:

cppCopy
1complex + other;

This makes code more readable and intuitive.

Advantages of Operator Overloading

• Makes code easier to read.
• Improves code reusability.
• Gives custom classes natural syntax.
• Supports object-oriented programming.

1. Division Operator (/)

The division operator can be overloaded for user-defined classes.

Example

cppCopy
1#include <iostream>
2
3using namespace std;
4
5class Number
6{
7private:
8    int value;
9
10public:
11    Number(int v)
12    {
13        value = v;
14    }
15
16    Number operator/(const Number& other)
17    {
18        return Number(value / other.value);
19    }
20
21    void display()
22    {
23        cout << value;
24    }
25};
26
27int main()
28{
29    Number n1(20);
30    Number n2(4);
31
32    Number result = n1 / n2;
33
34    result.display();
35
36    return 0;
37}

Output

textCopy
15

2. Subscript Operator ([])

The subscript operator allows objects to behave like arrays.

Example

cppCopy
1#include <iostream>
2
3using namespace std;
4
5class Array
6{
7private:
8    int data[5] = {10,20,30,40,50};
9
10public:
11    int operator[](int index)
12    {
13        return data[index];
14    }
15};
16
17int main()
18{
19    Array arr;
20
21    cout << arr[2];
22
23    return 0;
24}

Output

textCopy
130

3. Function Call Operator (())

The function call operator lets an object behave like a function.

Example

cppCopy
1#include <iostream>
2
3using namespace std;
4
5class Square
6{
7public:
8    int operator()(int x)
9    {
10        return x * x;
11    }
12};
13
14int main()
15{
16    Square square;
17
18    cout << square(6);
19
20    return 0;
21}

Output

textCopy
136

4. Stream Insertion Operator (<<)

The << operator is commonly overloaded to print objects using cout.

Example

cppCopy
1#include <iostream>
2
3using namespace std;
4
5class Student
6{
7private:
8    string name;
9
10public:
11    Student(string n)
12    {
13        name = n;
14    }
15
16    friend ostream& operator<<(ostream& out, const Student& s)
17    {
18        out << s.name;
19        return out;
20    }
21};
22
23int main()
24{
25    Student s("Ankit");
26
27    cout << s;
28
29    return 0;
30}

Output

textCopy
1Ankit

5. Increment Operator (++)

The increment operator can be overloaded.

Prefix Increment

cppCopy
1#include <iostream>
2
3using namespace std;
4
5class Counter
6{
7public:
8    int value = 0;
9
10    Counter& operator++()
11    {
12        value++;
13        return *this;
14    }
15};
16
17int main()
18{
19    Counter c;
20
21    ++c;
22
23    cout << c.value;
24
25    return 0;
26}

Output

textCopy
11

6. Decrement Operator (--)

The decrement operator decreases an object's value.

Example

cppCopy
1#include <iostream>
2
3using namespace std;
4
5class Counter
6{
7public:
8    int value = 5;
9
10    Counter& operator--()
11    {
12        value--;
13        return *this;
14    }
15};
16
17int main()
18{
19    Counter c;
20
21    --c;
22
23    cout << c.value;
24
25    return 0;
26}

Output

textCopy
14

7. Equality Operator (==)

The equality operator compares two objects.

Example

cppCopy
1#include <iostream>
2
3using namespace std;
4
5class Student
6{
7private:
8    int id;
9
10public:
11    Student(int i)
12    {
13        id = i;
14    }
15
16    bool operator==(const Student& other)
17    {
18        return id == other.id;
19    }
20};
21
22int main()
23{
24    Student s1(1);
25    Student s2(1);
26
27    if (s1 == s2)
28    {
29        cout << "Equal";
30    }
31
32    return 0;
33}

Output

textCopy
1Equal

8. Inequality Operator (!=)

The inequality operator checks whether two objects are different.

Example

cppCopy
1#include <iostream>
2
3using namespace std;
4
5class Student
6{
7private:
8    int id;
9
10public:
11    Student(int i)
12    {
13        id = i;
14    }
15
16    bool operator!=(const Student& other)
17    {
18        return id != other.id;
19    }
20};
21
22int main()
23{
24    Student s1(1);
25    Student s2(2);
26
27    if (s1 != s2)
28    {
29        cout << "Not Equal";
30    }
31
32    return 0;
33}

Output

textCopy
1Not Equal

Operators That Can Be Overloaded

Operators That Cannot Be Overloaded

The following operators cannot be overloaded:

• :: (Scope Resolution)
• . (Member Access)
• .* (Pointer-to-member)
• ?: (Conditional Operator)
• sizeof
• typeid

Best Practices

• Overload operators only when the meaning is intuitive.
• Keep operator behavior consistent with built-in types.
• Return references where appropriate to improve performance.
• Use const references for parameters to avoid unnecessary copies.
• Avoid overloading operators in ways that surprise users.

Practice Problems

1. Overload the + operator for a Complex class.
2. Overload the / operator for a Fraction class.
3. Create a custom container using the [] operator.
4. Overload the () operator for a calculator class.
5. Overload the << operator to print employee details.
6. Implement == and != for a Book class.
7. Implement prefix and postfix ++ operators for a counter class.

Interview Questions

1. What is operator overloading in C++?
2. Why is operator overloading useful?
3. Which operators can be overloaded?
4. Which operators cannot be overloaded?
5. What is the difference between prefix and postfix increment operator overloading?
6. Why is << usually implemented as a friend function?
7. When should operator overloading be avoided?
8. What are the benefits of overloading comparison operators?

Summary

In this module, you learned:

• What operator overloading is and why it is useful.
• How to overload the division (/) operator.
• How to implement the subscript ([]) and function call (()) operators.
• How to overload the stream insertion (<<) operator for output.
• How to overload increment (++) and decrement (--) operators.
• How to overload equality (==) and inequality (!=) operators.
• Best practices for writing clear, efficient, and intuitive overloaded operators.

Next Module: Module 20: Exception Handling — try, catch, throw, Standard Exceptions, Custom Exceptions, Exception Specifications, and Best Practices.