What is function overloading with examples?

Answer 1

Function overloading is where you declare the same function name with different signatures. The signature includes the return type.

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

char Max(char x, char y){ return( x>y?x:y ); }

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

The correct version of the function will be called depending on the type of the arguments you pass. So long as a matching signature exists, the call will succeed.

Note that in the examples shown, all the implementations are exactly the same. This is not always the case, but when it is it would make more sense to declare the function as a template function and let the compiler generate the specific overloads for you on an as-required basis.

template <class T>

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

You could also use a function-style macro to achieve the same end, but function-style macros are not type safe and are best avoided whenever possible.

Some examples of overloads with different implementations:

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

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

Class constructors also make use of overloading, the only difference being there is no return type to consider.

class Object{

pubic:

Object(); // Default constructor

Object(const Object&); // Copy constructor

Object(int); // User-defined constructor #1

Object(float, int); // User-defined constructor #2

Object(char, float, int); // User-defined constructor #3

}

In the example shown, all 5 constructors are overloads.

Overloads can also make use of default parameters, however care must be taken to ensure there is no ambiguity. For example:

void print() { Object *ptr = new Object(); print( *ptr ); delete( ptr ); }

void print(Object & ref){ ref.Print(); }

void print(Object * ptr = 0){ if( !ptr) print(); else print( *ptr ); } // Ambiguous!

In the above example, there is no way for the compiler to tell whether a call to print() should call the function with no parameters or call the function with a pointer parameter defaulting to NULL. To fix the ambiguity, the third declaration should not use a default parameter at all:

void print(Object * ptr){ if( !ptr) print(); else print( *ptr ); }

Better still, the three declarations could be reduced to just two overloads:

void print(Object * ptr = 0){ if( !ptr) { ptr = new Object(); print( *ptr ); delete( ptr ); } else print( *ptr); }

void print(Object & ref);