C++ for Beginners: C++ Function Overloading

Hits: 29

(C++ programming Example for Beginners)

C++ Function Overloading

In this tutorial, we will learn about the function overloading in C++ with examples.

In C++, two functions can have the same name if the number and/or type of arguments passed is different.

These functions having the same name but different arguments are known as overloaded functions. For example:


// same number different arguments
int test(){ }
int test(int a){ }
float test(double a){ }
int test(int a, double b){ }

Here, all 4 functions are overloaded functions.

Notice that the return types of all these 4 functions are not the same. Overloaded functions may or may not have different return types but they must have different arguments. For example,


// Error code
int test(int a){ }
double test(int b){ }

Here, both functions have the same name, the same type, and the same number of arguments. Hence, the compiler will throw an error.


Function Overloading using Different Types of Parameter


// Program to compute absolute value
// Works for both int and float

#include <iostream>
using namespace std;

// function with float type parameter
float absolute(float var){
    if (var < 0.0)
        var = -var;
    return var;
}

// function with int type parameter
int absolute(int var){
     if (var < 0)
         var = -var;
    return var;
}

int main(){
    
    // call function with int type parameter
    cout << "Absolute value of -5 = " << absolute(-5) << endl;

    // call function with float type parameter
    cout << "Absolute value of 5.5 = " << absolute(5.5f) << endl;
    return 0;
}

Output

Absolute value of -5 = 5
Absolute value of 5.5 = 5.5
Working of C++ Function Overloading for absolute()
Working of overloading for the absolute() function

In this program, we overload the absolute() function. Based on the type of parameter passed during the function call, the corresponding function is called.


Function Overloading using Different Number of Parameters


#include <iostream>
using namespace std;

// function with 2 parameters
void display(int var1, double var2){
    cout << "Integer number: " << var1;
    cout << " and double number: " << var2 << endl;
}

// function with double type single parameter
void display(double var){
    cout << "Double number: " << var << endl;
}

// function with int type single parameter
void display(int var){
    cout << "Integer number: " << var << endl;
}

int main(){

    int a = 5;
    double b = 5.5;

    // call function with int type parameter
    display(a);

    // call function with double type parameter
    display(b);

    // call function with 2 parameters
    display(a, b);

    return 0;
}

Output

Integer number: 5
Float number: 5.5
Integer number: 5 and double number: 5.5

Here, the display() function is called three times with different arguments. Depending on the number and type of arguments passed, the corresponding display() function is called.

Working of C++ Function Overloading for display()
Working of overloading for the display() function

The return type of all these functions is the same but that need not be the case for function overloading.


 

Note: In C++, many standard library functions are overloaded. For example, the sqrt() function can take doublefloatint, etc. as parameters. This is possible because the sqrt() function is overloaded in C++.

 

C++ for Beginners: C++ Function Overloading

Sign up to get end-to-end “Learn By Coding” example.



Disclaimer: The information and code presented within this recipe/tutorial is only for educational and coaching purposes for beginners and developers. Anyone can practice and apply the recipe/tutorial presented here, but the reader is taking full responsibility for his/her actions. The author (content curator) of this recipe (code / program) has made every effort to ensure the accuracy of the information was correct at time of publication. The author (content curator) does not assume and hereby disclaims any liability to any party for any loss, damage, or disruption caused by errors or omissions, whether such errors or omissions result from accident, negligence, or any other cause. The information presented here could also be found in public knowledge domains.