[Feature Request] operator overloading:

[nishant4500]

🚀 Feature Request

content for operator overloading:

Added fundamental theory
Examples for better understanding
Rules and pointers for the concept
Reviewed the content added

4. Operator Overloading

Introduction

Operator overloading allows you to redefine the way operators work for user-defined types (classes and structs). It enables you to specify more intuitive ways to perform operations on objects of your classes.

Overloading an operator does not change:

• the operator precedence,
• the associativity of the operator,
• the arity of the operator, or
• the meaning of how the operator works on objects of
  built-in types.

Syntax

An overloaded operator is implemented as a special member function with the keyword operator followed by the symbol of the operator being overloaded.

class ClassName {
public:
    ReturnType operatorOpSymbol (ParameterList) {
        // Function body
    }
};

Example

class Complex {
public:
    double real, imag;
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}
    // Overload the + operator
    Complex operator+ (Complex& obj) {
        return Complex(real + obj.real, imag + obj.imag);
    }
};

Types of Operators that Can Be Overloaded

• Arithmetic operators: +, -, *, /, %
• Relational operators: ==, !=, <, >, <=, >=
• Logical operators: &&, ||, !
• Bitwise operators: &, |, ^, ~, <<, >>
• Increment and decrement operators: ++, --
• Assignment operators: =, +=, -=, *=, /=, %=
• Subscript operator: []
• Function call operator: ()
• Member access operators: ->, . (only for pointers to members)
• Input and output operators: >>, <<

Operators that cannot be overloaded include: ::, .*, ., ? :, sizeof

Example:

#include <iostream>

class Complex {
public:
    double real, imag;

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

    // Overload the == operator
    bool operator== (const Complex& obj) const {
        return (real == obj.real && imag == obj.imag);
    }
};

int main() {
    Complex c1(3.0, 4.0), c2(3.0, 4.0);
    if (c1 == c2) {
        std::cout << "c1 and c2 are equal" << std::endl;
    } else {
        std::cout << "c1 and c2 are not equal" << std::endl;
    }
    return 0;
}

Operator Overloading Rules

When overloading operators, there are several rules to keep in mind:

1. Preserve the Operator's Original Meaning: The overloaded operator should make sense in the context of the operation it performs.
2. Return Types: The return type should be appropriate for the operation. For example, operator+ should return a new object, while operator+= should return a reference to *this.
3. Symmetry: Ensure symmetric behavior where applicable. For example, a == b should return the same result as b == a.
4. Do Not Overload Operators Irrelevantly: Only overload operators that make sense for your class. For example, overloading the arithmetic operators for a class that represents a complex number makes sense, but overloading them for a class that represents a database connection does not.

---

Would you like to work on this feature?

• Yes
• No

[nishant4500]

@ajay-dhangar can you please look into this..