- In some programming languages, it is
impossible to define two (or more)
(different) functions that has the
same name
Example:
void f(int i) { printf("i = %d\n\n", i); } void f(double f) { printf("f = %f\n\n", f); } - Non-object oriented programming languages,
such as the C programming language
do not allow this:
- Example Program:
(C with overloaded function name) ----
click here
- Try to compile this program with "cc overload01.c"
- Example Program:
(C with overloaded function name) ----
click here
- Object oriented programming languages,
such as
the C++ and Java programming language
DO allow this:
- Example Program:
(C++ with overloaded function name) ----
click here
- Try to compile this program with "CC overload02.C" and run it...
- Example Program:
(3 functions of the same name...) ----
click here
- Example Program:
(C++ with overloaded function name) ----
click here
- We say that a function is overloaded, when there are different functions with the same name.
- Don't worry, C++ can't read your mind....
It is very simple....
- C++ does not ONLY use the
function name to determine
which is the intended function
C++ uses function name and number and type of the actual parameters to determine the intended function....
- Therefore, a stupid machine like a computer can figure out that:
int i; double f; f(i); // will invoke f(int) f(f); // will invoke f(double)
- Be very careful when you invoke overloaded function
using constants:
void f(float f) { cout << "f = " << f << endl << endl; } void f(double d) { cout << "d = " << d << endl << endl; } int main(int argc, char *argv[]) { f(4.0); // Which f ??? } - Example Program:
(Try it out for yourself...) ----
click here
- To avoid any confusion which overloaded function to call, I recommend you type every constant that you use: (float) 4.0 or (double) 4.0.
- Recall that the expression
x * y is equivalent to a function call
operator*(x, y)
- Just like functions, operator functions (or operators) can be
overloaded.
We will see an example below.
- Overloaded functions is a great feature to exploit
when you need to implement the "same" function/operation
on different type of data.
- For example, the are many different types of
multiplication operations
(I use operation and function interchangably because
as you know, the function
operatorX is the same as the operation
X)
We have seen that C++ treats integer multiplication and float multiplication differently - due to the different internal encoding.
- A more visible example is
matrix-matrix multiplication
versus
matrix-vector multiplication that
we have just seen - which involves two different
algorithms defined by the programmer.
- We can use (exploit) function overloading
of C++ to write programs that can
select the proper function through
the context of the parameter types
- Example:
class Matrix3 { public: float A[3][3]; }; class Vector3 { public: float x[3]; };// ============================ Matrix-matrix multiply Matrix3 operator*(Matrix3 & M1, Matrix3 & M2) { Matrix3 r; int i, j, k; for (i = 0; i < 3; i=i+1) for (j = 0; j < 3; j=j+1) r.A[i][j] = 0; for (i = 0; i < 3; i=i+1) for (j = 0; j < 3; j=j+1) for (k = 0; k < 3; k=k+1) r.A[i][j] = r.A[i][j] + M1.A[i][k]*M2.A[k][j]; return r; } // ============================ Matrix-vector multiply Vector3 operator*(Matrix3 &M, Vector3 &v) { Vector3 z; int i, j; for (i = 0; i < 3; i=i+1) z.x[i] = 0; for (i = 0; i < 3; i=i+1) for (j = 0; j < 3; j=j+1) z.x[i] = z.x[i] + M.A[i][j]*v.x[j]; return z; }int main(int argc, char *argv[]) { Matrix3 M1, M2, M3; Vector3 v1, v2; M3 = M1 * M2; // Selects Matrix-matrix multiply // because operator*(Matrix3,Matrix3) v2 = M2 * v1; // Select Matrix-vector multiply // because operator*(Matrix3,Vector3) } - Example Program:
(Overloaded * operator) ----
click here