Function Overloading:-

 

  • Function overloading is compile time polymorphism.
  • Appropriate function call is resolved at compile time only.
  • This means writing a function with a same name but with the different definations.
  • There are some rules to write a n overloaded functions.
  • Functions are overloaded on to the basis of number of parameters and type of parameters.
  • C++ compilers differentiate the overloaded function by using naming decoration or name mangling.
  • We can also overload constructor but not destructor.
  • We can not overload a function depend on its return type value because at the time of calling the function return value is not considered.

 

#include<iostream.h>

class demo

{

public:

int i;

int j;

int fun()

{

cout<<“int”;

}

char fun()

{

cout<<“in char”;

}

};

 

int main()

{

int no;

demo h;

//

// We can not

//

no = h.fun();

return 0;

}

///

 

We can change a function by changing the type of a parameter.

 

class demo

{

public:

int i;

int j;

int fun(int i)

{

cout<<“in int”;

return 0;

}

int fun(char c)

{

cout<<“in char”;

return ‘c’;

}

};

 

int main()

{

int no;

demo h;

no = h.fun(‘a’); // in char

no = h.fun(97); // in int

no = h.fun((char)97); // in char

return 0;

}

 

C++ Reference Variables

 

///

 

class demo

{

public:

int i;

int j;

int fun(int i)

{

cout<<“in int”;

return 0;

}

 

int fun(float f)

{

cout<<“in float”;

return ‘c’;

}

};

 

int main()

{

int no;

demo h;

// Error

// Ambiguous call to function fun

//

no = h.fun(3.2);

no = h.fun(97);

return 0;

}

///

 

class demo

{

public:

int i;

int j;

int fun(int i)

{

cout<<“in int”;

return 0;

}

int fun(float f)

{

cout<<“in float”;

return ‘c’;

}

};

 

int main()

{

int no;

demo h;

no = h.fun(3.2f); // in float

no = h.fun(97); // in int

return 0;

}

///

 

We can overload a function by a pointer.

 

class demo

{

public:

int i;

int j;

int fun(int *i)

{

cout<<“in int*”;

return 0;

}

int fun(char *f)

{

cout<<“in char*”;

return ‘c’;

}

};

 

int main()

{

int no=10;

char c=’s’;

demo h;

no = h.fun(&no); // in int*

no = h.fun(&c); // in char*

return 0;

}

///

 

class demo

{

public:

int i;

int j;

int fun(const int i)

{

cout<<“in const”;

return 0;

}

 

int fun(int f)

{

cout<<“in int”;

return ‘c’;

}

};

 

int main()

{

int no=10;

demo h;

//

// Error ambiguous call

//

no = h.fun(no);

return 0;

}

///

 

We can not overload a function by using reference variable.

 

class demo

{

public:

int i;

int j;

//

// Function which accept reference

//

int fun(int &g)

{

cout<<“in reference”;

return 0;

}

int fun(int f)

{

cout<<“in int”;

return ‘c’;

}

};

 

int main()

{

int no=10;

demo h;

//

// Error ambiguous call

//

no = h.fun(no); //It is call by reference

return 0;

}

  • C++ distinguishes this overloaded function by using name mangling and name mangling decoration technique.
  • By using this technique, name of each of overloaded function is different.
  • For the name mangling, C++ compiler uses return value of the function and the parameter of the function.
  • By default all the function of C++ program uses name mangling technique.

For more reading about technology news in singapore and seo to online marketing do view more about other pages.

Written by Sourabh Bhunje

Sourabh Bhunje, B.E. IT from Pune University. Currently Working at Techliebe. Professional Skills: Programming - Software & Mobile, Web & Graphic Design, Localization, Content Writing, Sub-Titling etc. http://techliebe.com/about-us

Leave a Comment