Function Overloading in C++

Jul 10, 2024

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);
  1. Different types of parameters
void display(int);
void display(string);
  1. Different sequence of parameters
void func(int, double);
void func(double, int);
  1. 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)
  1. Default arguments
void add(int a, int b);
void add(int a, int b, int c = 0);
add(2, 3); // Error: Ambiguous matching
  1. 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