If any class have multiple functions with same names but different parameters then they are said to be overloaded. Function overloading allows you to use the same name for different functions, to perform, either same or different functions in the same class. If you have to perform one single operation but with different number or types of arguments, then you can simply overload the function.

1. FUNCTION OVERLOADING
Subject: Programming in C++
By Jasleen Kaur
Assistant Professor (CSE)

2. Function Overloading
• If any class have multiple functions with same
names but different parameters then they are said
to be overloaded. Function overloading allows you
to use the same name for different functions, to
perform, either same or different functions in the
same class.
• If you have to perform one single operation but with
different number or types of arguments, then you
can simply overload the function.

3. Way to Overload a Function
• By changing number of Arguments.
• By having different datatypes of argument.

4. • When an overloaded function is called, the
C++ compiler selects the proper function by
examining the number, types and order of
arguments in the function call.
• Function overloading is commonly used to
create several functions of same name that
perform similar tasks but on data of different
types.

5. Number of Arguments different
• In this, we can define two functions with same names but different
number of parameters of the same type. For example, in the below
mentioned program we have made two sum() functions to return
sum of two and three integers.
• Example
int sum (int x, int y)
{
cout << x+y;
}
Here sum() function is overloaded, to have two and three
arguments. Which sum() function will be called, depends on the
number of arguments.
int sum(int x, int y, int z)
{
cout << x+y+z;
}

6. Different Datatype of Arguments
• In this type of overloading we define two or
more functions with same name and same
number of parameters, but the type of
parameter is different. For example in this
program, we have two sum() function, first one
gets two integer arguments and second one
gets two double arguments.

7. Example
int sum(int x,int y)
{
cout<< x+y;
}
double sum(double x,
double y)
{
cout << x+y;
}
int main( )
{
sum (10,20);
sum(10.5,20.5);
}

8. WAP to overload square function which
calculate square of an int and square of
double.
Question for Practice

9. #include<iostream.h>
#include<conio.h>
int square(int x)
{
cout<<“square of integer”<<x<<“is”;
return x*x;
}
double square(double y)
{
cout<<“square of double”<<y<<“is”;
return y*y;
}

10. void main()
{
cout<<square(7);//calls int version
cout<<endl;
cout<<square(7.5); //calls double version
cout<<endl;
getch();
}

11. How Compiler differentiates
overloaded functions?
• Overloaded functions are distinguished by
their signatures.
• A signature is a combination of function’s
name and its parameter types(in order).
• Compiler encodes each function identifier
with the number and types of its parameters.
This is sometimes referred to as name
mangling.

12. • The compiler uses only parameter list to
distinguish between functions of same name.
How Compiler differentiates
overloaded functions?

13. void f(int x);
void f(int &x); // error
Two functions cannot be overloaded when the
only difference is that one takes a reference
parameter and the other takes a normal, call-by-
value parameter.

14. Functions can be distinguished on the basis of return type,
they cannot be overloaded on this basis.

15. Function with Default Arguments
• When we mention a default value for a parameter
while declaring the function, it is said to be as default
argument. In this case, even if we make a call to the
function without passing any value for that
parameter, the function will take the default value
specified.
• Example
sum(int x,int y=0)
{
cout << x+y;
}

16. Cont..
• Here we have provided a default value for y, during function
definition.
• Example
int main( )
{
sum(10);
sum(10,0);
sum(10,10);
}
• Output : 10 10 20 First two function calls will produce the exact
same value, for the third function call, y will take 10 as value
and output will become 20.
• By setting default argument, we are also overloading the
function. Default arguments also allow you to use the same
function in different situations just like function overloading.

17. Rules for using Default Arguments
• Only the last argument must be given default
value. You cannot have a default argument
followed by non-default argument.
• sum (int x, int y);
• sum (int x, int y=0);
• sum (int x=0, int y); // This is Incorrect

18. Rules for using Default Arguments
• If you default an argument, then you will have
to default all the subsequent arguments after
that.
– sum (int x,int y=0);
– sum (int x,int y=0,int z); // This is incorrect
– sum (int x,int y=10,int z=10); // Correct
• You can give any value a default value to
argument, compatible with its datatype.