Teach Yourself Borland C++ in 14 Days - portal

NOTE
NOTE
Up to Your Neck in C++
can create such a scenario thanks to function overloading. Here’s how the declarations for an
overloaded function look:
// declarations in C++
int multiply(int num1, int num2);
float multiply(float num1, float num2);
short multiply(short num1, short num2);
You still have to write separate functions for each of these declarations, but at least you can
use the same function name. The compiler takes care of calling the correct function based on
the parameters you pass the function. For example:
float x = 1.5;
float y = 10.5;
float result = multiply(x, y);
The compiler sees that two floats are passed to the function and calls the version of the
multiply() function that takes two floating-point values for parameters. Likewise, if two ints
are passed, the compiler calls the version of multiply() that takes two integers.
It is the parameter list that makes overloaded functions work. You can
vary either the type or the number of parameters a function takes (or
both), but you cannot create an overloaded function by changing just
the return value. For example, the following does not constitute an
overloaded function:
int DoSomething();
void DoSomething();
If you try to compile a program containing these lines, you will get a
compiler error that says, Type mismatch in redeclaration of
‘DoSomething()’. The two functions need to vary by more than just the
return value in order to have overloaded functions.
Compilers keep track of overloaded functions internally through a
process called name mangling. Name mangling means that the compiler
creates a function name that takes into account the parameter list of the
function. Internally, the compiler refers to the mangled name rather
than the plain text name you would recognize. For example, for the
multiply function taking two float values, the mangled name might be
multiply$qff.
87
3