The ability of the function to process the message or data in more than one form is called as function overloading. It implies that two or more functions in the same scope share the same name but their parameters are different. In this situation, the functions that share the same name are said to be overloaded and the process is called function overloading. The number and types of a function's parameters are called the function's signature.

Output:
it is integer 10
it is float 10.1
it is string Ten

class sale
{
int cost, discount;
public:
sale (sale&);
};
// non inline constructor
sale: : sale(sale&s)
{
cost = s.cost;
discount = s.discount;
}

Function overloading can be applied for constructors, as constructors are special functions of classes. A class can have more than one constructor with different signature. Constructor overloading provides flexibility of creating multiple type of objects for a class.
1. Memory is allocated for the objects.
2. Initialisation for the objects.

When you call an overloaded function (when there are many functions with same name), the compiler determines the most appropriate definition to use by comparing the argument types used to call the function with the parameter types specified in the definitions. The process of selecting the most appropriate overloaded function or operator is called overload resolution.
Example:
#include <iostream>
using namespace std;
void print (int i)
{
cout<<"It is integer" <<i<< endl;
}
void print (string c)
{
cout<<"It is string"<<e << endl;
}
int main()
{
print (10);
print ("Good");
return 0;
}
Output
It is integer 10
It is string Good

#include < iostream >
using namespace std;
class Area
{
int 1, b, a;
public:
area( );
area(int);
area(int, int);
area(area&);
void calculate ( )
};
area: .area ( )
{
cout < < "\n Enter the value of length and breath";
cin > > 1 > > b;
cout < < "\n\n non parameterized constructor";
}
area :: area (int c)
{
1=b=c;
cout < < "\n\n non parameterized constructor with one argument";
}
area ::area(int 11, int b 1)
{
cout < < "\n\n Non parameterized constructor with two argument";
1=11;
b=b1
}
area :: area(area & a)
{
=a1;
1= a.b;
cout < < "\n\n copy constructor";
}
void area::calculate ( )
{
a = 1*b;
cout < < a;
}
int main ( )
{
area obj;
cout < < "\n area of Rectangle is";
obj.calculate ( )
area obj1(2);
cout < < "\n area of Rectangle";
obj 1.calculatet);
area obj2 (2,3);
cout < < "\n area of Rectangle";
obj2.calculatet);
area obj3 (obj2); .
cout < < "\n area of Rectangle";
obj3.calculate ( );
return 0;
}
Output:
Enter the value of length and breadth 10 20
Non parameterized constructor area of Rectangle is 60
Parameterized constructor with one argument area of Rectangle 8
Parameterized constructor with two argument area of Rectangle 10
copy constructor area of Rectangle 10

#include < bit sf std C++.h >
using namespace std;
class Greeks
{
Public:
void func(int x)
{
cout < < "value of';
}
void func(double x)
{
cout < < "value of';
}
void func(int X, int)
{
cout < < "value of';
}
};
int inain ( )
{
Greeks obj 1;
obj 1.func(7);
obj 1.func(9 .132);
obj 1.func(85, 64);
return 0;
}
Output
value of x is 7
value of x is 9.132
value of x and y is 85, 64

#include< string.h >
#include< iostram >
using namespace std;
class strings
{
public:
char s[20];
void getstring( char str[])
{
strcpy(s,str);
}
void operator+(strings);
};
void strings::operator+(strings ob)
{
strcat(s,ob.s);
cout << "\nConcatnated String is:"<< s;
}
intmain()
{
strings ob 1, ob2;
char string 1 [10], string2[10];
cout << "\nEnter First String:";
cin>>string 1 ;
ob1.getstring(string 1);
cout << "\nEnter Second String:";
cin>>sting 2;
ob2.getstring(string2);
//Calling + operator to Join/Concatenate strings
obl +ob2;
return 0;
}
Output:
Enter First String:COMPUTER
Enter Second String:SCIENCE
Concatenated String is:COMPUTERSCIENCE

Output
Seminar starts now
Welcome to seminar
Recap of previous seminar content
Lectures in the seminar on
Vote of thanks
Vote of thanks
Vote of thanks

ReturnType classname :: Operator Operator Symbol (argument list)
{
\\ Function body
}
Example: Deposit Deposit: : operator + (Deposit d1);

Two function cannot be overloaded when the only difference is that one takes a reference parameter and the other takes a normal, call-by-value parameter.

The number and types of a function's parameters are called the function's signature.

C++ polymorphism is achieved through function overloading and operator overloading.

An overloaded function refers to a function having more than one distinct meaning.