🧾 UNIT III: Overloading and Inheritance

🔹 Operator Overloading in C++

🔸 Theory:

Operator overloading allows us to redefine the way operators work for user-defined types (like classes). In C++, this is done using special functions called operator functions. This enhances code readability and usability, enabling operations such as +, -, or == to work naturally with objects.

Syntax of operator overloading:

return_type class_name::operator op(argument_list) {
    // body
}

You can overload:

• Unary operators (e.g., ++, -, )
• Binary operators (e.g., +, , , /)
• Comparison operators (==, !=, <, >)
• Assignment operators (=, +=, =)

⚠️ Note: You cannot overload operators like ::, ., .*, sizeof, and ?:.

🔹 Overloading Unary Operators

🔸 Theory:

Unary operators work on a single operand. Overloading them allows applying operations like negation, increment, or decrement on objects.

Unary operator overloading in C++ allows the redefinition of operators that act on a single operand when applied to objects of user-defined types (classes). This enables customization of behavior for operators like ++ (increment), -- (decrement), - (unary minus/negation), and ! (logical NOT).

• **Prefix vs. Postfix Increment/Decrement:**For ++ and - operators, C++ distinguishes between prefix and postfix forms during overloading.

  • Prefix form (e.g., ++obj): operator++() (no arguments).
  • Postfix form (e.g., obj++): operator++(int) (the int argument is a dummy parameter used by the compiler to differentiate).

• Return Type:

  Overloaded unary operators can return any type, depending on the desired behavior. For example, unary minus might return a new object with negated values, while logical NOT might return a boolean.