Function Overloading and Default Arguments in C++

C++ supports function overloading and default arguments, which enhance the flexibility of function usage. Function overloading allows multiple functions with the same name to exist as long as their parameters differ. Default arguments allow you to assign default values to function parameters. This article explains both concepts with examples.

1. Function Overloading

Function overloading is the practice of defining multiple functions with the same name but with different parameter lists. The compiler differentiates them based on the number and types of parameters.

Syntax of Function Overloading

    return_type function_name(parameter_list_1);
    return_type function_name(parameter_list_2);

Example of Function Overloading

    #include <iostream>

    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) {
        return a + b;
    }

    int main() {
        int intResult = add(5, 3);
        double doubleResult = add(5.5, 3.3);

        std::cout << "Integer addition result: " << intResult << std::endl;
        std::cout << "Double addition result: " << doubleResult << std::endl;

        return 0;
    }

In this example:

  • There are two add functions: one takes integers as arguments, and the other takes doubles.
  • When add(5, 3) is called, the integer version is invoked.
  • When add(5.5, 3.3) is called, the double version is invoked.

2. Default Arguments

Default arguments allow you to assign a default value to one or more parameters in a function declaration. This way, if an argument is omitted during a function call, the default value is used.

Syntax of Default Arguments

    return_type function_name(parameter1 = default_value1, parameter2 = default_value2, ...);

Example of Default Arguments

    #include <iostream>

    void greet(std::string name = "User") {
        std::cout << "Hello, " << name << "!" << std::endl;
    }

    int main() {
        greet("Alice"); // Passes "Alice" as the name
        greet();        // Uses default value "User"

        return 0;
    }

In this example:

  • greet is defined with a default argument of "User".
  • When greet("Alice") is called, it prints Hello, Alice!.
  • When greet() is called without an argument, it uses the default value, printing Hello, User!.

3. Using Function Overloading with Default Arguments

Function overloading and default arguments can be combined for more flexibility. However, C++ does not allow functions to have identical parameter lists, even if default arguments are used.

Example of Combining Function Overloading and Default Arguments

    #include <iostream>

    void printMessage(std::string message, int times = 1) {
        for (int i = 0; i < times; i++) {
            std::cout << message << std::endl;
        }
    }

    void printMessage(int number) {
        std::cout << "Number: " << number << std::endl;
    }

    int main() {
        printMessage("Hello", 3);  // Calls string version with repeat count
        printMessage("Hello");     // Calls string version with default count
        printMessage(42);          // Calls int version

        return 0;
    }

In this example:

  • The printMessage function is overloaded. One version takes a string and an integer, while the other takes an integer only.
  • printMessage("Hello", 3) prints "Hello" three times.
  • printMessage("Hello") uses the default argument and prints "Hello" once.
  • printMessage(42) invokes the integer-only version.

4. Conclusion

Function overloading and default arguments allow C++ programmers to write flexible and reusable code. Function overloading enables the use of the same function name with different parameters, while default arguments reduce the need to provide all arguments explicitly, using default values when arguments are omitted.




Advertisement