What is overloading function in c and explain with example?

Answer 1

Short answer: You can't.

Long answer: Function overloading is when you define two functions with the same name that take different arguments, e.g.:

void pickNose(int fingerId);

void pickNose(Finger finger);

This is a valid construct in C++, which supports function overloading. If you try this in C, you'll get some error about function already defined.

Answer 2

Function overloading allows you to use the same function name with different parameter types. For instance, to determine the larger of two integers you might create the following function:

int max(int x, int y){ return(x>y?x:y); }

If you also wanted to determine the larger of two floats, then you need to overload the max function to accept floats:

float max(float x, float y){ return(x>y?x:y); }

Note that the only difference between these two functions is the parameter types and the return type. The compiler uses the parameter types to determine which of the two functions you are calling: if you pass two ints, the first overload is called, and if you pass two floats, the second is called.

In order to eliminate ambiguity, each overload must differ in the number or type of parameters passed. The exact combination of parameters is what distinguishes one function from another with the same name. This is known as the function signature. The return type plays no part in the signature, thus overloads cannot differ by return type alone.

Although the implementation of these functions is exactly the same, this needn't be the case for all overloads. If you wanted to determine the largest of three integers, for example, you could provide yet another overload:

int max(int x, int y, int z ){ return( max( max(x, y), z)); }

This overload calls the original version of the function twice, first to determine the largest of x and y, the result of which is then passed to the second call along with z, thus returning the largest of all three.

Note that function overloads must reside in the same namespace in order to be classed overloads. Functions with the same name but in separate namespaces are not overloads: thus it is possible to have two functions with exactly the same signature and return type. However, if both namespaces are in scope then the compiler cannot differentiate between them unless you explicitly resolve the ambiguity using the namespace resolution operator (::).

C++ also supports the concept of function templates. This is extremely useful when you have multiple overloads with the exact same implementation (as per the first int and float overloads shown above). Instead of manually coding all the possible variations you might need in order to cater for all types (including other primitives such as char or double, as well as user-defined types), you can define one template function for them all. The compiler will then generate the overloads for you, as and when they are required. Thus the max() function can be overloaded automatically with the following template:

template<class T>

T& max(T& x, T& y ){ return( x>y?x:y ); }

Here, T represents a single type, whether it be int, char, double or a user-defined type. So long as the type supports the greater-than operator (>), the compiler will generate the appropriate overload for you. Therefore all you have to do is call the function with an appropriate type.