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.

The term operator overloading, refers to giving additional functionality to the normal C++ operators like +, ++, -, --, +=, -=, *, <, >.It is also a type of polymorphism in which an operator is overloaded to give user defined meaning to it.
For example ¹+'operator can be overloaded to perform addition on various data types, like for Integer, String (concatenation) etc.

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

Rules for function overloading:
(i) The overloaded function must differ in the number of its arguments or data types.
(ii) The return type of overloaded functions are not considered for overloading same data type.
(iii) The default arguments of overloaded functions are not considered as part of the parameter list in function overloading