OOPortal 





Ad Hoc Polymorphism  «Prev  Next»
Lesson 3 Conversion and overloading
Objective Difference between conversion and overloading.
In the first part of this course, we will be focusing on ad hoc polymorphism, which has two forms:
  1. conversion
  2. overloading
Conversion
Conversion is the explicit or implicit change of value between types. A function or operator works on several different types by converting their values to the expected type. For example, a default constructor is by de facto a type conversion from the argument's type to the constructor's class type.

Overloading
Overloading of functions or operators gives the same function name or operator different meanings. When a function is overloaded, the same function name has different interpretations that depend on its signature--the list of argument types in the function's parameter list. When an operator is overloaded, the operator has different meanings depending on the types of its operands.
In this module, we will be looking at both conversion and function overloading in greater detail. Operator overloading is more involved and will be covered in a later module.
This module examines
  1. function overloading,
  2. copy constructors, and
  3. default arguments.
Function overloading is one of the defining aspects of the C++ programming language. Not only does it provide support for compile-time polymorphism, it also adds flexibility and convenience. Some of the most commonly overloaded functions are constructors. Perhaps the most important form of an overloaded constructor is the copy constructor. Closely related to function overloading are default arguments. Default arguments can sometimes provide an alternative to function overloading.

Function Overloading

Function overloading 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 use either different types of parameters or a different number of parameters. It is only through these differences that the compiler knows which function to call in any given situation. For example, this program overloads myfunc() by using different types of parameters
#include <iostream>
using namespace std;
int myfunc(int i); // these differ in types of parameters
double myfunc(double i);
int main(){
 cout << myfunc(10) << " "; // calls myfunc(int i)
 cout << myfunc(5.4); // calls myfunc(double i)
 return 0;
}
double myfunc(double i){
 return i;
}
int myfunc(int i){
 return i;
}
The next program overloads myfunc() using a different number of parameters:
#include <iostream>
using namespace std;
int myfunc(int i); // these differ in number of parameters
int myfunc(int i, int j);
int main(){
 cout << myfunc(10) << " "; // calls myfunc(int i)
 cout << myfunc(4, 5); // calls myfunc(int i, int j)
 return 0;
}
int myfunc(int i){
 return i;
}
int myfunc(int i, int j){
 return i*j;
}
As mentioned, the key point about function overloading is that the functions must differ in regard to the types and/or number of parameters. Two functions differing only in their return types cannot be overloaded. For example, this is an invalid attempt to overload myfunc():
int myfunc(int i); // Error: differing return types are
float myfunc(int i); // insufficient when overloading.
Sometimes, two function declarations will appear to differ, when in fact they do not. For example, consider the following declarations.
void f(int *p);
void f(int p[]); // error, *p is same as p[]