FUNCTION

OVERLOADING

In C++, two or more functions can sharethe same name as long as their parameter

declarations are different.

In this situation, the functions that sharethe same name are said to be overloaded,and the process is referred to as function

overloading

To see why function overloading is important,first consider three functions defined by the C subset: abs(), labs(), and fabs().

abs() returns the absolute value of an integer,

labs() returns the absolute value of a long, and

fabs() returns the absolute value of a double.

Although these functions perform almostidentical actions, in C three slightly different names must be used to represent these essentially similar tasks.

Example: Function Overloading

Function Overloading – DEFINITION

It is the process of using the same name for two or more functions.

The secret to overloading is that each redefinition of the function must useeither- • different types of parameters • different number of parameters.

The key to function overloading is a function’s argument list.

A function’s argument list is known as its signature.

Example :

Different types of arguments

Different number of parameters

void print(int a);void print (double b);void print(char c);

void area(float r);void area(float l, float b);void area(float a, float b, float c);

If two function have same number and types of arguments in the same order, they are said to have the same signature.

There is no importance to their variable names. • void print(int x, float y); • void print(int p, float q); are said to have same signature.

Calling Overloaded Function

Overloaded functions are called just like ordinary functions.

The signature determines which function among the overloaded functions should be

executed.print(3);

print(‘B’);

STEPS FOR FINDING BEST MATCH

The actual arguments are compared with formal arguments of the overloaded

functions and the best match is found through a number of steps.

In order to find the best match, the compiler follows the steps given below:

STEPS - 1 : Search for an exact match

If the type of the actual and formal argument is exactly the same, the compiler

invokes that function.void print(int x); // function #1void print(float p); // function #2 void print(char c); // function #3

-------------------------

print(5.3); //invokes the function #2

STEPS - 2 : A match through promotion

If no exact match is found, an attempt is made to achieve a match through

promotion.void print(int x); // function #1void print(float p); // function #2

void print(double f); // function #3-------------------------

print(‘c’); //matches the function #1 through promotion

STEPS - 3 : A match through standard C++ conversion rules

If the first and second steps fail, then an attempt is made to find a best match

through conversion rule.void print(char x); // function #1void print(float p); // function #2

-------------------------

print(342); //matches the function #2 int 342 is converted to float

STEPS - 4 : A match through user defined conversion

If all the above three steps fail to find a match, then an attempt is made to find a

match by applying user defined conversion rules.

Constructor Overloading

Just like any other function, constructors can also be overloaded.

We can use constructor overloading for initializing the objects based on different

conditions.

In Constructor Overloading, we need not call the constructor separately because

they are invoked automatically.

But

In Function Overloading, we have to invoke them separately.

Functions with Default Arguments Vs

Overloading

Functions with default arguments can be called with optional number of arguments

and hence it gives an appearance of function overloading.

float calc(float p, int q=8, float r=18.3);-------------------

float f = calc(3.5);float f = calc(3.5, 10);

OPERATOR

OVERLOADING

It is one type of Static Polymorphism.

C++ has about 45 operators. These operators are defined for the fundamental data types

(int, float etc).

While defining a class, we are actually creating a new datatype.

Most of the C++ operators can be overloaded to apply to our new class datatype.

Operator overloading is the concept of giving new meaning to

an existing C++ operator.

• When overloaded, the operators are implemented as functions using the operator keyword.

• For example, the syntax of overloading the addition operator “+” would be operator+().

One of the nice features of C++ is that you can give special meanings to operators, when they are used with user-defined classes. This is

called operator overloading.

You can implement C++ operator overloads by providing special

member-functions on your classes that follow a particular naming

convention. For example, to overload the + operator for your

class, you would provide a member-function named operator+ on your class.

1. Read the following function definition :void print(int x){ cout << x;}void print (float x) { cout << x;}void print(char x) { cout << x;}

a. All these functions can be used in the same program. Explain this feature of C++

b. Write sample statements to invoke each of these functions.

a) About FUNCTION OVERLOADING

b) print(35); print(32.7); print(‘M’);

2. Function with default arguments performs overloading. Explain this fact with the help of example.

• Functions with default arguments can be called with optional number of arguments and hence it gives an appearance of function overloading.float calc(float p, int q=8, float r=18.3);-------------------float f = calc(3.5);float f = calc(3.5, 10);

3. Why is function overloading connected to compile-time polymorphism or early binding?

• Early binding refers to the ability of the compiler to relate or bind a function call with the function definition during compilation itself. FUNCTION OVERLOADING comes under this category because it match the actual arguments with formal arguments during compile-time.