C++ Operator Overloading

Introduction

Operator overloading in C++ allows you to redefine the way operators work for user-defined types (such as classes and structs). This enables you to use operators with objects in a way that is intuitive and similar to how they are used with built-in types. By overloading operators, you can define custom behaviors for operations such as addition, subtraction, comparison, and more.

Defining Operator Overloading

To overload an operator, you define a special member function in your class or struct using the operator keyword followed by the operator you want to overload. The syntax for overloading operators varies slightly depending on whether you are overloading a unary or binary operator.

Example: Basic Operator Overloading

Let’s create a simple Complex class to represent complex numbers and overload the + operator to add two complex numbers.

#include <iostream>
using namespace std;

class Complex {
private:
    double real;
    double imag;

public:
    // Constructor
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}

    // Overload the + operator to add two Complex objects
    Complex operator + (const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }

    // Overload the << operator for output
    friend ostream& operator << (ostream& os, const Complex& c) {
        os << c.real << " + " << c.imag << "i";
        return os;
    }
};

int main() {
    // Create two Complex objects
    Complex c1(3.0, 4.0);
    Complex c2(1.0, 2.0);

    // Add the two Complex objects using the overloaded + operator
    Complex c3 = c1 + c2;

    // Output the result using the overloaded << operator
    cout << "c1: " << c1 << endl;
    cout << "c2: " << c2 << endl;
    cout << "c3: " << c3 << endl;

    return 0;
}

Output

c1: 3 + 4i
c2: 1 + 2i
c3: 4 + 6i

Explanation

• The Complex class represents a complex number with real and imaginary parts.
• The + operator is overloaded to add two Complex objects. The result is a new Complex object with the sum of the real and imaginary parts.
• The << operator is overloaded to output a Complex object in a readable format.

Overloading Other Operators

You can overload a wide range of operators in C++, including arithmetic, relational, and assignment operators. Here are some examples of overloading different types of operators.

Example 1: Overloading the == and != Operators

#include <iostream>
using namespace std;

class Complex {
private:
    double real;
    double imag;

public:
    // Constructor
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}

    // Overload the == operator to compare two Complex objects
    bool operator == (const Complex& other) const {
        return (real == other.real && imag == other.imag);
    }

    // Overload the != operator to compare two Complex objects
    bool operator != (const Complex& other) const {
        return !(*this == other);
    }

    // Overload the << operator for output
    friend ostream& operator << (ostream& os, const Complex& c) {
        os << c.real << " + " << c.imag << "i";
        return os;
    }
};

int main() {
    // Create two Complex objects
    Complex c1(3.0, 4.0);
    Complex c2(3.0, 4.0);
    Complex c3(1.0, 2.0);

    // Compare the Complex objects using the overloaded == and != operators
    cout << "c1 == c2: " << (c1 == c2) << endl;
    cout << "c1 != c3: " << (c1 != c3) << endl;

    return 0;
}

Output

c1 == c2: 1
c1 != c3: 1

Explanation

• The == operator is overloaded to compare two Complex objects for equality. It returns true if both the real and imaginary parts are equal.
• The != operator is overloaded to compare two Complex objects for inequality. It returns true if either the real or imaginary parts are not equal.
• The main function creates Complex objects and uses the overloaded operators to compare them.

Example 2: Overloading the [] Operator

#include <iostream>
using namespace std;

class Array {
private:
    int arr[10];

public:
    // Constructor to initialize the array elements to zero
    Array() {
        for (int i = 0; i < 10; i++) {
            arr[i] = 0;
        }
    }

    // Overload the [] operator to access array elements
    int& operator[](int index) {
        if (index < 0 || index >= 10) {
            cout << "Index out of bounds" << endl;
            // Returning a reference to a static variable to avoid undefined behavior
            static int errorValue = -1;
            return errorValue;
        }
        return arr[index];
    }
};

int main() {
    Array a;

    // Use the overloaded [] operator to access and modify array elements
    a[0] = 10;
    a[1] = 20;

    // Print the array elements
    cout << "a[0]: " << a[0] << endl;
    cout << "a[1]: " << a[1] << endl;

    // Access an out-of-bounds index
    cout << "a[10]: " << a[10] << endl;

    return 0;
}

Output

a[0]: 10
a[1]: 20
Index out of bounds
a[10]: -1

Explanation

• The Array class contains an array of 10 integers.
• The [] operator is overloaded to provide bounds-checked access to the array elements. If an out-of-bounds index is accessed, an error message is displayed and a reference to a static error value is returned.
• The main function uses the overloaded [] operator to access and modify the array elements and demonstrates accessing an out-of-bounds index.

Guidelines for Operator Overloading

1. Maintain Intuitiveness: Overloaded operators should behave in a way that is intuitive and consistent with their typical use.
2. Use Friend Functions When Necessary: Use friend functions for overloading operators that need access to private or protected members of a class.
3. Return References When Modifying Objects: When overloading operators that modify the state of an object (e.g., +=), return a reference to the current object to allow chaining.

Example: Overloading the += Operator

#include <iostream>
using namespace std;

class Complex {
private:
    double real;
    double imag;

public:
    // Constructor
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}

    // Overload the += operator to add another Complex object
    Complex& operator += (const Complex& other) {
        real += other.real;
        imag += other.imag;
        return *this;
    }

    // Overload the << operator for output
    friend ostream& operator << (ostream& os, const Complex& c) {
        os << c.real << " + " << c.imag << "i";
        return os;
    }
};

int main() {
    // Create two Complex objects
    Complex c1(3.0, 4.0);
    Complex c2(1.0, 2.0);

    // Use the overloaded += operator
    c1 += c2;

    // Output the result
    cout << "c1: " << c1 << endl;

    return 0;
}

Output

c1: 4 + 6i

Explanation

• The += operator is overloaded to add another Complex object to the current object and return a reference to the current object.
• The main function demonstrates using the overloaded += operator to add two Complex objects.

Conclusion

Operator overloading in C++ enhances the flexibility and readability of your code by allowing custom behaviors for operators when used with user-defined types. This chapter covered the basics of defining operator overloading, provided examples of overloading various operators, and offered guidelines for effective operator overloading. Understanding and effectively using operator overloading is essential for writing intuitive and maintainable C++ programs.