FUNCTION OVERLOADING
Subject: Programming in C++
By Jasleen Kaur
Assistant Professor (CSE)
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.
Way to Overload a Function
• By changing number of Arguments.
• By having different datatypes of argument.
• 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.
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;
}
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.
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);
}
WAP to overload square function which
calculate square of an int and square of
double.
Question for Practice
#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;
}
void main()
{
cout<<square(7);//calls int version
cout<<endl;
cout<<square(7.5); //calls double version
cout<<endl;
getch();
}
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.
• The compiler uses only parameter list to
distinguish between functions of same name.
How Compiler differentiates
overloaded functions?
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.
Functions can be distinguished on the basis of return type,
they cannot be overloaded on this basis.
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;
}
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.
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
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.

03 function overloading

  • 1.
    FUNCTION OVERLOADING Subject: Programmingin C++ By Jasleen Kaur Assistant Professor (CSE)
  • 2.
    Function Overloading • Ifany 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 Overloada Function • By changing number of Arguments. • By having different datatypes of argument.
  • 4.
    • When anoverloaded 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 Argumentsdifferent • 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 ofArguments • 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,inty) { 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 overloadsquare 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<<“squareof 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 intversion cout<<endl; cout<<square(7.5); //calls double version cout<<endl; getch(); }
  • 11.
    How Compiler differentiates overloadedfunctions? • 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 compileruses only parameter list to distinguish between functions of same name. How Compiler differentiates overloaded functions?
  • 13.
    void f(int x); voidf(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 bedistinguished on the basis of return type, they cannot be overloaded on this basis.
  • 15.
    Function with DefaultArguments • 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 wehave 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 usingDefault 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 usingDefault 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.