Operator Overloading in C++ | C++ Programming Tutorial

1. Introduction to Operator Overloading

Operator overloading enables you to define how operators work with your custom classes. By overloading operators, you can make your classes interact with operators in a natural way.

2. Syntax of Operator Overloading

Operators are overloaded by defining functions with the keyword operator followed by the operator symbol.


returnType operator op (parameters) {
    // implementation
}

op is the operator symbol you want to overload.

3. Types of Operator Overloading

3.1 Unary Operators

Unary operators operate on a single operand. Examples include ++, --, -, and !.


class Complex {
private:
    double real, imag;
public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}

    // Overloading unary - operator
    Complex operator - () const {
        return Complex(-real, -imag);
    }

    void display() const {
        std::cout << real << " + " << imag << "i\n";
    }
};

3.2 Binary Operators

Binary operators operate on two operands. Examples include +, -, *, /, and ==.


class Complex {
private:
    double real, imag;
public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}

    // Overloading binary + operator
    Complex operator + (const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }

    void display() const {
        std::cout << real << " + " << imag << "i\n";
    }
};

3.3 Comparison Operators

Comparison operators such as ==, !=, <, >, <=, and >= can be overloaded to compare objects.


class Complex {
private:
    double real, imag;
public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}

    // Overloading == operator
    bool operator == (const Complex& other) const {
        return (real == other.real) && (imag == other.imag);
    }

    void display() const {
        std::cout << real << " + " << imag << "i\n";
    }
};

3.4 Stream Insertion and Extraction Operators

These are << and >> operators used for input and output.


class Complex {
private:
    double real, imag;
public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}

    // Overloading << operator
    friend std::ostream& operator << (std::ostream& out, const Complex& c) {
        out << c.real << " + " << c.imag << "i";
        return out;
    }

    // Overloading >> operator
    friend std::istream& operator >> (std::istream& in, Complex& c) {
        in >> c.real >> c.imag;
        return in;
    }
};

3.5 Subscript Operator

The subscript operator [] can be overloaded to access elements in a class like an array.


class Array {
private:
    int* arr;
    int size;
public:
    Array(int s) : size(s) {
        arr = new int[size];
    }

    // Overloading [] operator
    int& operator [] (int index) {
        return arr[index];
    }

    ~Array() {
        delete[] arr;
    }
};

3.6 Function Call Operator

The function call operator () allows an object of a class to be called as if it were a function.


class Functor {
public:
    // Overloading () operator
    void operator () (int x) const {
        std::cout << "Value: " << x << std::endl;
    }
};

4. Rules and Guidelines

Symmetry: If you overload an operator as a member function, it should be done consistently with its usual behavior.
Friend Functions: For operators that need access to private members, use friend functions.
Performance Considerations: Overloading should be efficient and not introduce unnecessary overhead.
Logical Consistency: Ensure the overloaded operators maintain logical consistency with their usual operations.

5. Examples

Example of Overloading + and - Operators


class Vector {
private:
    double x, y;
public:
    Vector(double a = 0, double b = 0) : x(a), y(b) {}

    // Overloading + operator
    Vector operator + (const Vector& v) const {
        return Vector(x + v.x, y + v.y);
    }

    // Overloading - operator
    Vector operator - (const Vector& v) const {
        return Vector(x - v.x, y - v.y);
    }

    void display() const {
        std::cout << "(" << x << ", " << y << ")\n";
    }
};

Example of Overloading ++ Operator


class Counter {
private:
    int count;
public:
    Counter(int c = 0) : count(c) {}

    // Overloading ++ operator (prefix)
    Counter& operator ++ () {
        ++count;
        return *this;
    }

    // Overloading ++ operator (postfix)
    Counter operator ++ (int) {
        Counter temp = *this;
        ++count;
        return temp;
    }

    void display() const {
        std::cout << count << std::endl;
    }
};

Welcome to C++ Programming Tutorial