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)

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

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)

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

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

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

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

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

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

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)

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

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

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

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

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