Function Overloading: Polymorphism

• Polymorphism means having many forms, messages are displayed in more than one form
• A person who is a father, husband, and employee exhibits polymorphism because they show different behavior in different situations
• Polymorphism is a key feature of Object-Oriented Programming

Types of Polymorphism

• Compile-time Polymorphism
• Runtime Polymorphism

Compile-Time Polymorphism

• Achieved through function overloading or operator overloading

Function Overloading

• Multiple functions share the same name but have different parameters
• Functions are overloaded by changing the number or type of arguments
• Object-oriented programming feature listing many functions with the same name but distinct parameters for numerous tasks under one name

Advantages of Function Overloading

• Improves code readability and allows code reusability
• Saves memory space, consistency, and readability
• Speeds up program execution
• Simplifies code maintenance
• Adds flexibility to code
• Allows functions to perform different operations while using the same names for similar operations

Disadvantages of Function Overloading

• Function declarations differing only in return type cannot be overloaded
• Member function declarations with the same name and parameter types cannot be overloaded if any are static members
• Requires the compiler to perform name mangling in the function name to include argument types

Operator Overloading

• C++ provides a special function to change the current functionality of some operators within its class
• Changes some specific operators' functions to do different tasks

Operator Overloading Syntax

Return_Type classname :: operator op(Argument list)
{
    Function Body
}

• Return_Type is the value type that is returned to another object

• operator op is the function where the operator is a keyword

• op is the operator being overloaded

• C++ allows operators to have special meanings for data types, called operator overloading

• The addition operator (+) can concatenate strings for the string class

• A single operator "+" can add integer operands or concatenate string operands

Types of Operators in C++ That Can Be Overloaded

• Arithmetic Operators: +, -, *, /, %

• Relational Operators: ==, !=, <, >, <=, >=

• Logical Operators: &&, ||, !

• Bitwise Operators: &, |, ^, ~, <<, >>

• Assignment Operators: =, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=

• Increment and Decrement Operators: ++, --

• Unary Operators: +, -, *, &, !, ~

• Binary Operators: +, -, *, /, %, &, |, ^, <<, >>

• Special Operators: new, delete, sizeof, typeid

• The operator '+' is overloaded in the example to add two imaginary or complex numbers, instead of integers or floating-point numbers

Operator Overloading Approaches

• Overloading Unary Operator
• Overloading Binary Operator

Criteria/Rules to Define the Operator Function

• For a non-static member function, the binary operator should have one argument and the unary operator should have none
• For a friend function, the binary operator must have two arguments, while the unary operator should have one
• Operators that cannot be overloaded are .* :: ?:
• Operators that cannot be overloaded when declaring the function as a friend are = () [] ->
• The operator function must be a non-static member function, global free function, or a friend function

Overloading Unary Operator

• No arguments are passed in the unary operator function which works with only one class object, overloading an operator on a single operand

Overloading Binary Operator

• The binary operator overloading function should have one argument to be passed and operate on two operands

Overloading Unary Operator (Member Function)

• operator++() overloads to increment a value
• The ++obj calls the overloaded function, modifying the value

Overloading Binary Operator (Member Function)

• The + operator overloads to add two complex numbers
• The function returns a new Complex object with the sum of real and imaginary parts

Overloading Binary Operator (Friend Function)

• The operator+ is defined as a friend function to access private members
• The function performs addition and returns a new Complex object

Overloading Comparison Operators

• Comparison operators (==, !=, <, >, <=, >=) compare objects, requiring overloading for user-defined data types

Key Concepts for Overloading Comparison Operators

• Overloaded comparison operators must return a boolean value (true or false)
• Implemented as const member functions to prevent operand modification
• Can be overloaded using member functions or friend functions

Example Overloading Comparison Operators

• == operator is overloaded to compare the value of two objects
• != operator is overloaded to check inequality
• The function returns true if values match/don't match for the ==/!= operators

Overloading Arithmetic Assignment Operators

• Allow modifying user-defined objects in a way that mirrors built-in data types

Key Concepts for Overloading Arithmetic Assignment Operators

• Modify the left-hand operand
• Return *this to allow method chaining
• Can be overloaded as member functions

Examples of Overloading Arithmetic Assignment Operators

• += operator adds the value of one object to another
• -= operator subtracts the value of one object from another
• Returning *this allows method chaining

Function Overriding

• Function overriding occurs when a member function of a class is redefined in a derived class inherited from the base class
• The function signature remains the same, but the function's operation is altered to meet the needs of the derived class
• Calling the function using the parent object executes the parent class function
• Calling the function using the child object executes the child class version

Real-Life Example of Function Overriding

• The Constitution of India takes the structure, procedures, and powers of government institutions, fundamental rights, and duties
• Other real world examples are the RBI (The Reserve Bank of India) and other state banks like SBI, PNB, ICICI, etc.

Types of Function Overriding

• Compile Time Overriding
• Runtime Function Overriding

Compile-Time Function Overriding

• The function call and definition are bound at compilation
• Also known as early or static binding

Runtime Function Overriding Using Virtual Function

• Function overriding performs at both compile time and runtime

• The call to the overridden function resolves during compile time

• Called early binding when the function call binds to its definition during compilation

• Function overriding performs at runtime, hence the function call binds to its definition during runtime

• Known as late or dynamic binding, achieved using virtual functions

• The override keyword tells the compiler to declare the overridden function as virtual in the parent class

Advantages of Runtime Function Overriding

• Methods are selected at runtime based on object type
• Interface and implementations can be reused for base class
• Changes in base classes automatically affect derived classes
• Facilitates implementation of design patterns
• Client code interacts with the base class instead of specific implementations to reduce coupling

Limitations of Runtime Function Overriding

• Virtual function calls are slower than non-virtual function calls due to virtual table lookup
• Implementing and maintaining polymorphic code can be more complex
• Virtual tables and pointers add to memory overhead
• Errors might only be detected at runtime, leading to bugs

Examples of Function Overriding

• The C++ program calls the overridden function from the derived class

• When using a pointer of the parent type that points to an object of the derived class, the base class function is called

• Using a child class object calls overridden functions from each class