Function Overloading in C++

Introduction

• Previous Topic: Default arguments in functions
• Current Topic: Function Overloading
  • Part of polymorphism in OOP concepts (Abstraction, Classes & Objects, Encapsulation, Polymorphism)

Function Overloading

• Definition: Having multiple functions with the same name but different parameters (type, number, or order)
• Need: Simplifies readability, maintainability, and reusability
  • Allows using a single function name for different types of operations

Examples

• Declaration:

  void display(int);
  void display(string);
  

• Definition:

  void display(int a) { cout << a; }
  void display(string str) { cout << str; }
  

• Calling:

  display(2);     // Calls display(int)
  display("Jen"); // Calls display(string)
  

Advantages

• Single function name for various types
• Increased program readability and maintainability
• Better program reusability

Compiler Handling

• Compiler decides which function to call based on the type and number of arguments

Forms of Function Overloading

1. Different number of parameters

void add(int, int);
void add(int, int, int);

2. Different types of parameters

void display(int);
void display(string);

3. Different sequence of parameters

void func(int, double);
void func(double, int);

4. Not based on return type: Overloading cannot be achieved solely by changing the return type.

void func();
int func(); // Error

Achieving Overloading with Examples

• Different types of parameters

  void display(int a) { cout << a; }
  void display(string str) { cout << str; }
  display(3); // Calls display(int)
  display("Jen"); // Calls display(string)
  

• Different number of parameters

  void add(int a, int b) { cout << a + b; }
  void add(int a, int b, int c) { cout << a + b + c; }
  add(2, 3); // Calls add(int, int)
  add(2, 3, 4); // Calls add(int, int, int)
  

• Different sequence of parameters

  void func(int a, double b) { cout << a << b; }
  void func(double a, int b) { cout << a << b; }
  func(3, 10.4); // Calls func(int, double)
  func(10.4, 3); // Calls func(double, int)
  

Ambiguity in Function Overloading

1. Type conversion

void print(int a);
void print(double b);
print(10.2); // Error: Ambiguous matching between print(int) and print(double)

2. Default arguments

void add(int a, int b);
void add(int a, int b, int c = 0);
add(2, 3); // Error: Ambiguous matching

3. Pass by reference

void func(int a);
void func(int& b);
int x = 6;
func(x); // Error: Ambiguous matching

Considerations

• Be cautious of type conversion, default arguments, and pass-by-reference to avoid ambiguous errors
• Ambiguity can arise due to implicit conversions, leading to compiler errors
• Function overloading increases code readability and reusability but requires careful implementation

Conclusion

• Function overloading is a powerful feature but must be used carefully to avoid ambiguities
• Provides a way to use a single function name for multiple tasks, enhancing code readability and maintainability
• Requires careful handling of potential ambiguities and compiler dependencies

Next Steps

• Further coding exercises on functions and function overloading